text:
  App Service Acmebot

  Automated ACME SSL/TLS certificates issuer for Azure App Service (Web Apps / Functions / Containers)

## Motivation

We have started to address the following requirements:

- Support for multiple App Services
- Easy to deploy and configure
- Highly reliable implementation
- Ease of Monitoring (Application Insights, Webhook)

You can add multiple certificates to a single App Service.

## Feature Support

- Azure Web Apps and Azure Functions (Windows)
- Azure Web Apps (Linux) / Web App for Containers (Windows and Linux, requires Azure DNS)
- Azure App Service Environment (Windows and Linux)
- Issuing a certificate to the Deployment Slot
- Issuing certificates for Zone Apex Domains
- Issuing certificates with SANs (subject alternative names) (one certificate for multiple domains)
- Wildcard certificate (requires Azure DNS)
- Support for multiple App Services in a single application
- ACME-compliant Certification Authorities
  - [Let's Encrypt](https://letsencrypt.org/)
  - [Buypass Go SSL](https://www.buypass.com/ssl/resources/acme-free-ssl)
  - [ZeroSSL](https://zerossl.com/features/acme/) (Requires EAB Credentials)

[![architectural diagram](docs/images/acmebot-diagram.svg)](https://www.lucidchart.eu/documents/view/77879337-7889-41d9-bd2d-c3a184f9587b)

## Deployment

| Azure (Public) | Azure China | Azure Government |
| :---: | :---: | :---: |
|  |  |  |

Learn more at https://github.com/shibayan/appservice-acmebot/wiki/Getting-Started

## Thanks

- [ACMESharp Core](https://github.com/PKISharp/ACMESharpCore) by @ebekker
- [Durable Functions](https://github.com/Azure/azure-functions-durable-extension) by @cgillum and contributors
- [DnsClient.NET](https://github.com/MichaCo/DnsClient.NET) by @MichaCo

## License

This project is licensed under the [Apache License 2.0](https://github.com/shibayan/appservice-acmebot/blob/master/LICENSE)

repository: shibayan/appservice-acmebot

repo_name: shibayan/appservice-acmebot


text:
# ministorage
localStorage-/sessionStorage-compatible in-memory store

MiniStorage is meant to be as compatible with localStorage/sessionStorage as possible, having the signatures and return values as its localStorage/sessionStorage counterparts.

## Installation

```
$ npm install ministorage
```

## Usage

```javascript
import Storage from 'ministorage';

const store = new Storage();

store.setItem('hello', 'world');
store.getItem('hello');

store.clear();
```

MiniStorage also includes polyfills for localStorage and sessionStorage for environments that don't support them out of the box. (The polyfills are meant to be used in CommonJS environments.)

```
require('ministorage/polyfill');
```

If you wish to only polyfill one specific storage, this can be done with:

```
require('ministorage/polyfill/localstorage');

// or

require('ministorage/polyfill/sessionstorage');
```

These also work in environments where sessionStorage or localStorage don't have any quota by default. (Firefox incognito mode or Safari incognito mode.)
While the data in those modes will not get persisted, it helps to counteract the `DOM Exception 22` errors from your own code or third-party modules.

## License

MIT

license: MIT

repository: frostney/ministorage

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: frostney/ministorage


text:
TIY-Assingments

 **ASSIGNMENT 07
 ** READING JavaScript: Events**
  * [ ] How does an `Event` "bubble"? Can I make it stop?
  There actually a couple of things happening here depending. There is something called "Capturing" and it is when the outer
  most element is fired and responds to whatever has been triggered regardless of its position.
  The Bubble response happens like this: when an even listener responds to a triggered event it responds from the inner most
  element to the outer most element in its response.  There is no real upside to either method in particular although certain
  versions of IE 9 and under, Capturing was the main method used
  an onclick happens when the user clicks an item and can respond as the page is opening.
  an onload is when the element can only be accessed or triggered by the user clicking AFTER
  the page has completely loaded.

  * [ ] What does the `target` property of an `Event` refer to?
  the target event property returns the element that triggered the event.It is referring to the actual event that is triggered
  during the action performed. refers to the internal firing process of an event and its trigger

  * [ ] Besides `click`, what _other_ event types can I trigger with my mouse?
  , mouse events would be like onkeypressonclick, onmousemove, onmouseup,
  form event examples would be onblur onchange onfocusin etc.

  * [ ] What types of events can be triggered on a `<form>` element?
  submission of filled field
  <form> events examples are onblur onchange onreset onselect onsubmit

  * [ ] `click` me, baby, one more time!
  a mouse action which can trigger any number of events . some actions must be "double clicked" or "right clicked"
  etc. depending on the OS and the model and capabilities of the mouse
  and many of the mouse events can invove a click or double click

  * [ ] `scroll` down the avenue
  the scroll is a feature that allows the user to navigate through options or a list  or whatever it may be,
  by scrolling the page using the mouse dial, or wheel

   * [ ] `change` is a-comin' changes
 could be referring to the Hash
 or in frame objects it is onhashchange-when and event occurs after changes to the anchor part of a URL(?)
 // I need to have this explained
 onchange	The event occurs when the content of a form element, the selection, or the checked state have
 changed (for <input>, <keygen>, <select>, and <textarea>)
	 ref:http://www.w3schools.com/jsref/dom_obj_event.asp

   * [ ] `submit` to mah authah-ri-tah!
  this a way of triggering an event by its very action of entering the info into the provided blank field.
 onsubmit is example this event occurs when a form is submitted like in the responsive column

    * [ ] this is a complete `load`...
   onloaddata onloadeddate onloadstart
frame object load example would be like onload in which the event occurs when an object has loaded

  * [ ] well, just `unload` about it.
onbeforeunload this is when the event occurs before the document is about to be loaded
**READING JavaScript: Events**

*How does an Event "bubble"? Can I make it stop?* this was brought into existence to deal
with the ability of multiple actions to trigger the same event so two or more event handlers
it is the opposite of capturing
bubbling:he event is first captured and handled by the innermost element and then propagated to outer elements.
capturing, the event is first captured by the outermost element and propagated to the inner elements.

*
ref:http://stackoverflow.com/questions/4616694/what-is-event-bubbling-and-capturing

More Questions
Homework Assignments
**What interactive elements exist?**
the feature basically opens like an accordion, thus its name, and reveals (n) number of
features as a subset to the default display

**How do you interacts with them?**
clicks, could be a mouse rollover or

**What visual effects are produced by interacting?**
the accordion expands
**How does it do it?**

**What existing HTML elements are changed?**

**What new HTML elements are created?**

**What CSS styles are used to produce the effect?**

**_View Mode Switch_**it allows basic switching of views like rollover menu items creating a small pop up box.
this is considered to be at entity level

**What does it do?**
it creates new options on the user end in the form of alternate viewpoints of popuated elements
**What interactive elements exist?**
 there is toggle action of a graphically renderred button of some sort that when
 clicked by the user, offers an alternate orginizational view of the
 items populating the page
 ;it creates new options on the user end

**How do you interact with them?**
rollovers and clicks, submits

**What visual effects are produced by interacting?**
 the pop up box of some sort
 a change in view for the view switch. example: button in corner
 that when toggled presents the user with an alternate view of the elements populating
 the page

**How does it do it?**

**What existing HTML elements are changed?**

**What new HTML elements are created?**

**What CSS styles are used to produce the effect?**

**Responsive Multi-Column Form**
this is basically a two or more columned blueprint for the document object
model and an example would be a submittal form for instance

**What does it do?**

**What interactive elements exist? **
rollovers, clicks, tabs work

**How do you interact with them?**
 clicks rollover prompts

**What visual effects are produced by interacting?**
 The fields are populated with the info that the user inputs.

**How does it do it?**

**What existing HTML elements are changed?**

**What new HTML elements are created?**

**What CSS styles are used to produce the effect?**

 CSS columns which can be applied really to any element.
 I need to confirm but I think you can use nests two multi-responsive columns inside one another


text:
---
layout: post
title:  "AWS 學習筆記 - Storage Gateway"
description: "This article is a memo recorded when learning AWS Storage Gateway"
date: 2017-05-16 04:30:00
published: true
comments: true
categories: [aws]
tags: [AWS, Storage Gateway]
---

Storage Gateway
===============

AWS Storage Gateway is a service that connects an on-premises software appliance with cloud-based storage to provide seamless and secure integration between an organization's on-premises IT environment and AWS's storage infrastructure. The service enables you to securely store data to the AWS cloud for scalable and cost-effective storage.

![Storage Gateway (1)](https://image.slidesharecdn.com/3-170425003051/95/deep-dive-on-the-aws-storage-gateway-april-2017-aws-online-tech-talks-4-638.jpg?cb=1493080374)

AWS Storage Gateway's software appliance is available for download as a virtual machine (VM) image that you install on a host in your datacenter. Storage Gateway supports either VMware ESXi or Microsoft Hyper-V. Once you've installed your gateway and associated it with your AWS account through the activation process, you can use the AWS Management Console to create the storage gateway option that is right for you.

## AWS 標準定義

AWS Storage Gateway is a hybrid storage service that enables your on-premises applications to seamlessly use [storage in the AWS Cloud](https://aws.amazon.com/what-is-cloud-storage/). You can use the service for backup and archiving, disaster recovery, cloud bursting, storage tiering, and migration. Your applications connect to the service through a gateway appliance using standard storage protocols, such as NFS and iSCSI. The gateway connects to AWS storage services, such as Amazon S3, Amazon Glacier, and Amazon EBS, providing storage for [files](https://aws.amazon.com/storagegateway/#fileserver), [volumes](https://aws.amazon.com/storagegateway/#volume), and [virtual tapes](https://aws.amazon.com/storagegateway/#VTL) in AWS. The service includes a highly-optimized data transfer mechanism, with bandwidth management, automated network resilience, and efficient data transfer, along with a local cache for low-latency on-premises access to your most active data.

Four Types of Storage Gateways
==============================

- File Gateway (NFS)

- Volumes Gateway (iSCSI)
    - Stored Volumes
    - Cacahed Volumes

- Tape Gateway (VTL)

## File Gateway (比較不常考)

Files are stored as objects in your S3 buckets, accessed through a Network File System (NFS) mount point. Ownership, permissions, and timestamps are durably stored in S3 in the user-metadata of the object associated with the file. Once objects are transferred to S3, they can be managed as native S3 objects, and buckets policies such as versioning, lifecycle management, and cross-region replication apply directly to objects stored in your bucket.

![Storage Gateway (2)](http://docs.aws.amazon.com/storagegateway/latest/userguide/images/file-gateway-concepts-diagram.png)

> file gateway 一般會以 VM 會放在 on-premises 的環境上，但也可以是在 VPC 內的一個 EC2 instance

## Volume Gateway (virtual hard disks)

The volume gateway interface presents your applications with disk volumes using the iSCSI block protocol.

Data written to these volumes can be asynchronously backed up as point-in-time snapshops of your volumes, and stored in the cloud as Amazon EBS snapshots.

Snapshots are incremental backups that captures only changed blocks. All snapshot storage is also compressed to minimized your storage charges.

> 資料以非同步的方式存到 接著進行 snapshot 之後再存放到 S3 上 (incrementally)

### (1) Stored Volumes

Stored volumes let you store your primary data locally, while asychronnously backing up that data to AWS. Stored volumes provide your on-premises applications with low-latency access to their entire datasets, while providing durable, off-site backups. You can create storage volumes and mount them as iSCSI devices from your on-premises application servers. Data written to your stored volumes is stored on your on-premises storage hardware. This data is asynchronously backed up to Amazon Simple Storage Service (Amazon S3) in the form of Amazon Elastic Block Store (Amazon EBS) snapshots. 1GB - 16TB in size for Stored Volumes.

![Volume Gateway - Stored Volumes](http://docs.aws.amazon.com/storagegateway/latest/userguide/images/aws-storage-gateway-stored-diagram.png)

> 本地端保留完整資料(complete copy)

### Cached Volumes

Cached volumes let you use Amazon Simple Storage Service (Amazon S3) as your primary data storage while retaining frequently accessed data locally in your storage gateway. Cacahed volumes minimize the need to scale your on-premises storage infrastructure, while still providing your applications with low-latency access to their frequently accessed data.

You can create storage volumes up to 32 TB in size and attach to them as iSCSI devices from your on-premises application servers. Your gateway stores data that you write to these volumes in Amazon S3 and retains recently read data in your on-premises storage gateway's cache and upload buffer storage. 1GB - 32TB in size for Cached Volumes.

![Volume Gateway - Cached Volumes](http://docs.aws.amazon.com/storagegateway/latest/userguide/images/aws-storage-gateway-cached-diagram.png)

> 所有的資料都會存到 AWS，在本地端只保留常用的部份資料(**Read Data**)，因此本地端實際上並不需要很大的儲存空間

> 從上面的架構圖來說，寫入的資料會被移到 AWS S3 存放，但讀取資料則是從本地端的 Gateway VM 的 Cache Storage 中取得

## Volume Gateway (Tap Gateway)

Tap Gateway offers a durable, cost-effective solution to archive your data in AWS cloud. The VTL interface it provides lets you leverage your existing tape-based backup application infrastructure to store data on virtual tape cartridges that you create on your tape gateway. Each tape gateway is preconfigured with a media changer and tape drivers, which are available to your existing client backup applications as iSCSI devices. You add tape cartridges as you need to archive your data. Supported by NetBackup, Backup Exec, Veam etc.

![Volume Gateway - Tap Gateway](http://docs.aws.amazon.com/storagegateway/latest/userguide/images/Gateway-VTL-iSCSI-vtl-diagram.png)

Exam Tips
=========

- **File Gateway**: For flat files, stored directly on S3

- **Volume Gateway**
    - **Stored Volumes** - Entire Dataset is stored on site and is asynchronously backed up to S3.
    - **Cached Volumes** - Entire Dataset is stored on S3 and the most frequently accessed data is cached on site.

- **Gateway Virtual Tape Library (VTL)**: Used for backup and uses popular backup applications like NetBackup, Backup Exec, Veam etc

References
==========

- [What Is AWS Storage Gateway? - AWS Storage Gateway](http://docs.aws.amazon.com/storagegateway/latest/userguide/WhatIsStorageGateway.html)


text:
## Worker runtime environment

In addition to any environment variables pre-configured for your worker via `watchbot.template()` (see below), Watchbot will provide each worker with a set of environment variables representing the details of the message which it should process:

Name | Description
--- | ---
Subject | the message's subject
Message | the message's body
MessageId | the message's ID defined by SQS
SentTimestamp | the time the message was sent
ApproximateFirstReceiveTimestamp | the time the message was first attempted
ApproximateReceiveCount | the number of times the message has been attempted

The environment will also contain some variables referencing resources that Watchbot created:

Name | Description
--- | ---
WorkTopic | the ARN of the SNS topic that provides messages to SQS
LogGroup | the name of the CloudWatch LogGroup where logs are sent

**:lock: Encrypting & decrypting environment variables**

The recommended flow for deploying Watchbot stacks is to use [cfn-config](http://github.com/mapbox/cfn-config) which provides a `--kms` option for automatically encrypting CloudFormation parameters marked with `[secure]`. To decrypt at runtime, install [decrypt-kms-env](https://github.com/mapbox/decrypt-kms-env) as a dependency in your Dockerfile and invoke it in your `CMD`. Example:

```Dockerfile
RUN eval $(./node_modules/.bin/decrypt-kms-env) && npm start
```

## Worker completion

The exit code from your worker determines what the watcher will do with the message that was being processed. Your options are:

Exit code | Description | Outcome
--- | --- | ---
0 | completed successfully | message is removed from the queue without notification
3 | rejected the message | message is removed from the queue and a notification is sent
4 | no-op | message is returned to the queue without notification
other | failure | message is returned to the queue and a notification is sent

When a message is returned to the queue, it will be retried. [See the worker retry documentation](./worker-retry-cycle.md) for more info.

license: ISC

repository: mapbox/ecs-watchbot

gha_language: JavaScript

gha_license_id: ISC

repo_name: mapbox/ecs-watchbot


text:
# Matryoshka tic-tac-toe

![Matryoshka tic-tac-toe in real life](media/matryoshka-tic-tac-toe.gif)

![Wonder if this is still a solved game](media/ed.png)

~~No.~~

~~The computational requirements explode after 5 pieces.~~

~~The 6 pieces of the video are unsolved.~~

## Yes.
Through exhaustive searching with an efficient min-max algorithm, all game
states for 3, 4, 5 and 6 piece per player games have been checked.

## Features

  - A 2-player, local game of matryoshka tic-tac-toe
    - `src/game/main.rs -> target/release/game`

Harder than it looks!

  - Solver
    - `src/solver/main.rs -> target/release/solver`
    - A single player game against the CPU
    - Min-max algorithm
      - Efficient
      - Highly parallel
        - Any move in a 7-piece game will pin every core of a 64 vCPU Graviton instance
      - Alpha-beta pruning
      - Pruning of symmetrical branches
      - Heuristics for the most expansive search-spaces
    - Lookup table
      - Fully solved for games of 3/4/5/6 pieces

You can't win. It is hard to avoid losing.

  - Lookup generator
    - `src/lookup-generator/main.rs -> target/release/lookup-generator --help`

## Example

![Example game](media/example-game.png)

branch_name: refs/heads/main


text:
# socket.io-raft

[![NPM version](https://badge.fury.io/js/socket.io-raft.svg)](http://badge.fury.io/js/socket.io-raft)

Adapter to enable broadcasting of events to multiple separate socket.io server nodes without third-party dependencies.

This adapter leverages the [Raft](https://ramcloud.stanford.edu/raft.pdf) consensus algorithm to broadcast messages around.

**No need to manage a Redis cluster only for websockets!**

## How to use

```js
const io = require('socket.io')(3000);
const raftAdapter = require('socket.io-raft');
// Setup a three node raft cluster (localhost:8000 to localhost:8002)
io.adapter(raftAdapter({ port: 8000, peers: ['tcp://localhost:8001', 'tcp://localhost:8002'] }));
```

By running socket.io with the `socket.io-raft` adapter you can run
multiple socket.io instances in different processes or servers that can
all broadcast and emit events to and from each other.

So any of the following commands:

```js
io.emit('hello', 'to all clients');
io.to('room42').emit('hello', "to all clients in 'room42' room");

io.on('connection', (socket) => {
  socket.broadcast.emit('hello', 'to all clients except sender');
  socket.to('room42').emit('hello', "to all clients in 'room42' room except sender");
});
```

will properly be broadcast to the clients using the Raft Concensus protocol.

## API

To be documented.

## TODO

- [x] Broadcast support
- [ ] Room support
- [ ] Robustness
- [ ] Persistent rooms leveraging the Raft log


text:
# Changelog

All notable changes to this project will be documented in this file.

## Release 1.1.2

**Bugfixes**
- Fix readme ToC

## Release 1.1.1

**Bugfixes**
- Fix code quality

## Release 1.1.0

**Features**
- Switch from [negativo17 - Multimedia](https://negativo17.org/multimedia/) to [RPM Fusion free](https://rpmfusion.org/) after a version update broke the installation
- Add rspec-puppet unit tests
- Add RuboCop linting
- Prepare project for Puppet Forge

**Bugfixes**
- Code partially broken after latest release [\#4](https://github.com/Jarodiv/puppet-ffmpeg/issues/4)

## Release 1.0.1

**Bugfixes**
- Fix dependency name

## Release 1.0.0

Full rewrite

**Features**
- Remove support for RHEL and Amazon Linux

repository: Jarodiv/puppet-ffmpeg

gha_language: Ruby

repo_name: Jarodiv/puppet-ffmpeg


text:
# LJ Code 301 - Day 11

***

Today we learned the JavaScript library page.js.  Page.js is a really powerful tool that allows us to manipulate the content of the webpage without reloading the page.  It is the basic principle that single page applications are built off of.  Frameworks such as react and angular use identical routing functionality to allow people to build single page applications.  Learning routing was very cool because it is a fairly advanced topic that is frequently used in industry.

In addition to learning page.js we got to practice our skills with the server and database.  My skills with those things are getting much better, and I look forward to developing them further.


text:
# Complex numbers

## imaginary number

- $x^2 = -1$ it is **impossible to square a real number and get a negative number**
- However, a solution does exist in a new number system called the **complex number system**

### imaginary unit

- $i = sqrt(-1)$ is an imaginary unit

| 1       | i       | -1      | -i      |
| ------- | ------- | ------- | ------- |
| $i^0$   | $i^1$   | $i^2$   | $i^3$   |
| $i^4$   | $i^5$   | $i^6$   | $i^7$   |
| $vdots$ | $vdots$ | $vdots$ | $vdots$ |

- The pattern $1, i, -1, -i$ repeats

> The previously unsolvable equation is now solvable with the addition of the imaginary unit

## Pure imaginary numbers

- A complex number that has no real part
- By taking multiples of $i$, we can create infinitely many more pure imaginary numbers.

### Example

- $3i$ is a square root of $-9 = 9 (-1)$ is purely imaginary

repository: zironyx/cheatsheets

repo_name: zironyx/cheatsheets


text:
# PatternLockJS
A pattern lock library for the web. [Demo](https://phenax.github.io/pattern-lock-js/)

[![forthebadge](http://forthebadge.com/images/badges/uses-js.svg)](http://forthebadge.com)
[![forthebadge](http://forthebadge.com/images/badges/you-didnt-ask-for-this.svg)](http://forthebadge.com)
[![forthebadge](http://forthebadge.com/images/badges/no-ragrets.svg)](http://forthebadge.com)

### Installation

Install the library with
```bash
yarn add @phenax/pattern-lock-js
```

Import the library with
```js
import PatternLock from '@phenax/pattern-lock-js';
```

### Get started
```javascript
const patternLock = new PatternLock({
    el: '#patternLock',
    dimens: { width: 300, height: 430 },
});
```

### Customize the theme
```javascript
patternLock.setTheme({
    accent: '#1abc9c',     // Accent color for node
    primary: '#ffffff',    // Primary node and line color
    bg: '#2c3e50',         // Canvas background color
    dimens: {
        node_radius: 20,   // Radius of the outer ring of a node
        line_width: 6,     // Thickness of the line joining nodes
        node_core: 8,      // Radius of the inner circle of a node
        node_ring: 1,      // Outer ring thickness
    }
});
```

### Create the grid
```javascript
patternLock.generateGrid(3, 3);
```

### Start
```javascript
patternLock.start();
```

### Callback for when the pattern is complete
```javascript
patternLock.onPatternComplete = nodes => {
    // Check if the pattern is right
};
```

### Converting pattern to mapped words and hashing
```javascript
patternLock.onPatternComplete= nodes => {
    const password = PatternLock.patternToWords(nodes);
    alert('hashed password is : ' + PatternLock.hashCode(password));
};
```


text:
# API Review 05/26/2022

## API Additions for Required Members

**Approved** | [#roslyn/61444](https://github.com/dotnet/roslyn/issues/61444#issuecomment-1139053906)

### API Review

`WithRequired` -> `WithIsRequired`. Otherwise, this looks good for the initial API. Future APIs can be added as needed.
## Higher Level SyntaxProvider APIs for incremental generators

**NeedsWork** | [#roslyn/54725](https://github.com/dotnet/roslyn/issues/54725#issuecomment-1139062813)

### API Review

Overall the approach has promise, but we have some notes to look at before finalizing.

* AttributeData is provided in multiple places.
* GeneratorAttributeSyntaxContext might want to provide the target symbol
* If we keep the syntax generic parameter, a better name might be `TAttributeTarget`
* Our analyzers don't use generics, they use SyntaxKinds. Maybe we should do the same: it will allow filtering to multiple declaration kinds, and potentially make calling more ergonomic by allowing the user to leave off the generic arguments.
  * We might also be able use SymbolKinds instead, to allow language agnosticism?
* The non-transform overload should be removed. We don't think it's necessary, and could lead users down a pit of failure by causing more recalculation later in the pipeline.

repository: dotnet/apireviews

gha_license_id: MIT

repo_name: dotnet/apireviews


text:
# naemon-availability-report

First, create a Mysql view in statusengine DB using the below command

```CREATE VIEW service_monitor_time_range AS select hostname, service_description, min(start_time) AS min_start_time,max(start_time) AS max_start_time from statusengine_servicechecks group by hostname, service_description```

It will spit out 4 CSV files.

* Service Availability: This sheet contains an overview of the duration the given service was in each state as well as the percentage calculation for the same. It comprises of 2 parts:

  * Contractual: The contractual data does not take the state changes and state durations into calculation during the maintenance windows. In simple terms, if a service is under maintenance for 1 hour and the report is generated for that day, the total time considered for all states would be 23 hours.

  * Actual: The actual data does not care whether a service was in maintenance or not. It gives the data for the entire duration which gives the state of the service, its duration and its percentage duration, without taking into consideration whether the service was in maintenance or not.

*	Service Planned Downtime: This workbook contains the list of maintenance windows for the service, including the comments, start time and end time of every maintenance window for that service.

*	Service Unplanned Outage: This workbook contains entries for each of the non-OK state for the service along with when did the non-OK state start and end, based in Contractual concept i.e. does not contain the entries when the service was under maintenance.

*	Service Overall Outage: This workbook contains entries for each of the non-OK state for the service along with when did the non-OK state start and end, based in Actual concept i.e. contains the entries of non-OK states even when service was under maintenance.

# Tables and Views used:

* statusengine_service_downtimehistory (Table): Contains the information of all the maintenance windows
* statusengine_service_downtimehistory (View): Contains the information about timestamp when the service was placed under monitoring and the timestamp of the last check performed.
* statusengine_service_statehistory (Table): Contains the information about all the state changes of the services
* statusengine_servicechecks (Table): Contains the information about every single check ever performed.


text:
---
layout: post
status: publish
published: true
title: stevecrozz' custom nginx binary for ubuntu 0.7.59
author:
  display_name: stevecrozz
  login: stevecrozz
  email<EMAIL_ADDRESS>  url: http://lithostech.com
author_login: stevecrozz
author_email<EMAIL_ADDRESS>author_url: http://lithostech.com
wordpress_id: 78
date: '2009-06-08 19:45:36 -0700'
date_gmt: '2009-06-09 03:45:36 -0700'
categories:
- Uncategorized
tags:
- ubuntu
- web server
- nginx
comments: []
---
{% responsive_image path: static/img/full/2009/nginx-logo.png alt:
"nginx logo" class: "img-float-left" %} The nginx build in the official
ubuntu package repository is somewhat out-of-date, so I built my own
package from source using
[0.7.59](http://www.nginx.eu/download/sources/nginx-0.7.59.tar.gz). I'm
going to provide it here in case anyone else would like it. One of the
new features I like is the
[try_files](http://wiki.nginx.org/NginxHttpCoreModule#try_files)
directive. Here's an example of what I'm doing using 0.6.35, the full
post is here
[http://lithostech.com/lighten-apaches-load-nginx](http://lithostech.com/lighten-apaches-load-nginx):

~~~ nginx
location / {
  root /var/www/fresnobeehive.com;
  proxy_set_header X-Forwarded-For  $remote_addr;
  if (-f $document_root/beehive$uri) {
    rewrite (.*) /beehive$1 break;
  }
  if (-f $request_filename) {
    break;
  }
  if (-f $request_filename/index.html) {
    rewrite (.*) $1/index.html break;
  }
  if (-f $document_root/beehive$uri/index.html) {
    rewrite (.*) /beehive$1/index.html break;
  }
  if (!-f $request_filename) {
    proxy_pass http://fresnobeehive.com:8080;
    break;
  }
}
~~~

<!--more-->

Here's the same thing using the new try_files syntax:

~~~ nginx
upstream backend {
  server fresnobeehive.com:8080;
}
location / {
  try_files /beehive/$uri /beehive/$uri/index.html $uri $uri/index.html @mt;
}
location @mt {
  proxy_pass http://backend;
  proxy_set_header X-Forwarded-For  $remote_addr;
  proxy_set_header Host $host;
}
~~~

Attached is a copy of my newer build of nginx, you are free to use my
version as long as you don't expect me to support it or provide any kind
of assurance that it actually works. Here's the configure line so you
can see what I have enabled/disabled. I have disabled a lot of things so
make sure you look it over.

~~~ bash
./configure $(CONFIGURE_OPTS) \
    --conf-path=/etc/nginx/nginx.conf \
    --error-log-path=/var/log/nginx/error.log \
    --pid-path=/var/run/nginx.pid \
    --lock-path=/var/lock/nginx.lock \
    --http-log-path=/var/log/nginx/access.log \
    --http-client-body-temp-path=/var/lib/nginx/body \
    --http-proxy-temp-path=/var/lib/nginx/proxy \
    --http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
    --with-http_flv_module \
    --with-http_ssl_module \
    --without-mail_pop3_module \
    --without-mail_smtp_module \
    --without-mail_imap_module \
    --without-http_ssi_module \
    --without-http_userid_module \
    --without-http_auth_basic_module \
    --without-http_autoindex_module \
    --without-http_browser_module
~~~

**Update**
I've removed the links to these files because newer and supported
versions of nginx are being distributed with with 9.10. You're much
better off using those anyway. This was only a stopgap.

extension: markdown


text:
# Neural Binary Gates

**Neural Binary Gates** is a simple artificial neural network that represents
a problem related with digital binary gates. The operation that predict this
network is **X = (A xor B) and (A or C)**.

For resolve this problem I has designed a network with the foundations of
MLP (Multilayer Perceptron) and an architecture 3-3-1.

This network was built with Python 3.6 and Keras package. The network is represented
with *Dense* objects layers and use the optimizer SGD.

Finally for easy the use of this representation and test it I has deployed the
abstraction trained model on *Google Cloud ML Engine*, you can use the python
file *predict.py* for check the results.


text:
# SubstrateApiSidecarV1.NodeNetwork

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**nodeRoles** | [**NodeRole**](NodeRole.md) |  | [optional]
**numPeers** | **String** | Number of peers the node is connected to. | [optional]
**isSyncing** | **Boolean** | Whether or not the node is syncing. `False` indicates that the node is in sync. | [optional]
**shouldHavePeers** | **Boolean** | Whether or not the node should be connected to peers. Might be false for local chains or when running without discovery. | [optional]
**localPeerId** | **String** | Local copy of the `PeerId`. | [optional]
**localListenAddresses** | **[String]** | Multiaddresses that the local node is listening on. The addresses include a trailing `/p2p/` with the local PeerId, and are thus suitable to be passed to `system_addReservedPeer` or as a bootnode address for example. | [optional]
**peersInfo** | [**[PeerInfo]**](PeerInfo.md) |  | [optional]


text:
## `stencila/libcore` : core function library

[![experimental](https://img.shields.io/badge/stability-experimental-orange.svg)](http://github.com/badges/stability-badges)
[![Code coverage](https://codecov.io/gh/stencila/libcore/branch/master/graph/badge.svg)](https://codecov.io/gh/stencila/libcore)
[![Community](https://img.shields.io/badge/join-community-green.svg)](https://community.stenci.la)
[![Chat](https://badges.gitter.im/stencila/stencila.svg)](https://gitter.im/stencila/stencila)

This the Stencila Core Library, a library of functions that are built in to Stencila's [Mini language](https://github.com/stencila/mini). It is to Stencila what [Excel functions](https://support.office.com/en-us/article/Excel-functions-alphabetical-b3944572-255d-4efb-bb96-c6d90033e188) are to Excel, the [Python Standard Library](https://docs.python.org/3/library/index.html) is to Python, the [R Base Package](https://stat.ethz.ch/R-manual/R-devel/library/base/html/00Index.html) is to R, etc, etc.

[See the comprehensive list of LibCore functions.](https://github.com/stencila/libcore/tree/master/funcs)

Want to contribute a function to Libcore? [See the contribution guidelines.](https://github.com/stencila/libcore/blob/master/CONTRIBUTING.md).

Stencila functions can be implemented, and used, in a variety of languages. Mini is intentionally simple.  This allows functions to be implemented using the best language for the job. And when a function is implemented in multiple languages, this approach allows for the optimization of function calls based on implementation speed and data location. [Learn more about Mini](https://github.com/stencila/mini).

### [`meta`](meta)

A folder for cordinating design and implementations of functions across langages.

### [`funcs`](funcs)

A folder containing source code for LibCore. Each function is defined in a separate files. The functions are written
in JavaScript (since Mini is written in this language).

### [`tests`](tests)
A folder containing tests for LibCore functions.

repository: stencila/libcore

repo_name: stencila/libcore


text:
# Creating a new release

1. Update the Version string in `version/version.go`.
2. Add new release notes to the Changelog.
3. Open a PR with above changes.
4. Once the above PR is merged, tag `main` with the new version, e.g. `v0.1.1`. Push the tags. This will kick off a CI workflow, which will publish a draft GitHub release.
5. Update Release Notes on the new draft GitHub release, and publish that.

repository: honeycombio/libhoney-go

gha_language: Go

repo_name: honeycombio/libhoney-go


text:
### Custom HTTP Port
Voyager 3.2+ supports opening http port in any non custom port.

```yaml
apiVersion: voyager.appscode.com/v1beta1
kind: Ingress
metadata:
  name: test-ingress
  namespace: default
spec:
  rules:
  - host: appscode.example.com
    http:
      port: '8989'
      paths:
      - backend:
          serviceName: test-service
          servicePort: '80'
  - host: appscode.example.com
      http:
        port: '4343'
        paths:
        - backend:
            serviceName: test-service
            servicePort: '80'

```

For this configuration, the loadbalancer will listen to `8989` and `4343` port for incoming HTTP connections, and will
pass any request coming to it to the desired backend.

> For one Ingress Type you cannot have multiple rules listening to same port, even if they do not have
same `host`.

repository: pierreozoux/voyager

repo_name: pierreozoux/voyager


text:
### Male mold part 2

 Now, get part no. 3 and mill one face on an angle of 15°. Then, mill the other face to an opposite angle of 15°, until the width of the narrow face matches the face of part 5 (see last image). That should be 14,19mm in the narrower face and 21mm in the wider face.

(Drawings page 7)


text:
Revamp
======

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

Tiny opinionated MVP framework for Android. Retains presenters on rotation.

Adding to your project
----------------------

Add this to your dependencies:

```groovy
compile 'io.nlopez.revamp:library:1.1.1'
```

Usage
-----

Please refer to the [sample](sample) for seeing it in action.

Contributing
------------
Forks, patches and other feedback are welcome.

Creators
--------

Nacho López - Github [@mrmans0n](https://github.com/mrmans0n) - Twitter [@mrmans0n](https://twitter.com/mrmans0n) - Blog [nlopez.io](http://nlopez.io)

License
-------

[MIT License](LICENSE)

gha_language: Java


text:
# Professional Readme Generator

![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)

## Table of Contents:
  1. [Description](#description)
  2. [Installation](#installation)
  3. [Usage](#usage)
  4. [License](#license)
  5. [Contributing](#contributing)
  6. [Tests](#tests)
  7. [GitHub](#gitHub)
  8. [Contact](#contact)
  9. [Other](#other)

## Description

This application allows users to generate a Readme markdown file.

## Installation

Uses must have Visual Studio (VS) and inquirer npm installed.

## Usage

This application generates a Readme by asking a series of questions in the VS integradted terminal. Once all the questions have been answered, the Readme is generated in the current working directory on the left-hand side of the screen.

## License

MIT

## Contributing

To discuss any contributions, please reach out to Mary Lou Hoover.

## Tests

N/A

## GitHub

Let's Connect! [mlh19](https://www.github.com/mlh19)
## E-mail

Email Me! [ml.hoover<EMAIL_ADDRESS>
## Video

[Link to Video](https://watch.screencastify.com/v/QJmUKQBvPxKU50HCUGIO)

## Other
- Worked on this assignment with Todd Taylor and Damien Luzzo
- Used most of unit 09 resources and in-class activities
- [GitHub Pages Link]()


text:
traverse-object
===============

Traverse a Javascript object tree (assuming it is not cyclic) and call a callback for each found node.

In addition, you can filter all property paths (e.g. 'user.0.firstName') by an Array of `RegExp` or Strings
so that you only visit the nodes you care about.

Definition
==========

    traverse(object, callback, propertiesStrOrRegEx = undefined)

- `object` (required): any iterable (e.g. by `in`) Javascript `Object`.
- `callback` (required): a function to call on every matched property. Has signature `(obj, path, value)`. `obj`
  will be the immediate parent object of the match. `path` will be an `Array` of the full path to the current match.
  `value` will be the value of the matched property. Return `true` from the callback if you want to stop traversing.
- `propertiesOrStrOrRegEx` (optional): a filter for which properties to visit. A `String`, `RegExp`, or an `Array`
  of mixed Strings or RegExps. If you do not pass this argument, then every descendent property is visited and the
  callback will be called for all of them.

Property paths and `propertiesOrStrOrRegEx` Wildcards
=====================================================

While traversing the tree of objects, the current path is considered to be a `.`-delimited String. This String is
tested against the value(s) in `propertiesOrStrOrRegEx`, which can zero or more explicit `RegExp` instances or Strings.

Strings are converted to `RegExp` objects where the `*` character is considered a `.*`. For example the String
`'*firstName'` will be converted into `new RegExp(".*firstName")`. Regular expressions are cached between calls but
`lastIndex=0` is explicitly set before each test to ensure that there is not state leaking between calls.

For example, if you want to visit the tree for any property with a path that ends in `'firstName'` you could pass in
`'*firstName'`. If you want to visit the tree for all properties that have `'firstName'` anywhere in their path, you
can pass in `'*firstName*'`.

Simple Example
==============

    var traverse = require('traverse-object');

    let user = {
      firstName: 'Joshua',
      lastName: 'Jung',
      profession: {
        name: 'Software Engineer',
        contributions: ['trie-search', 'traverse-object']
      }
    };

    traverse(user, console.log); // Will output (obj, path, value) for each key in the tree

Advanced Example
================

Sanitize an object tree of all passwords and oauth tokens:

    var traverse = require('../index');

    let users = [
      { name: 'Josh', password: 'asdfasdf1234' },
      { name: 'Matej', token: 'testtest' },
      { name: 'Elisia', password: 'asdfasdf1234' },
      { name: 'Jonas' },
      { name: 'Lasse', password: 'asdfasdf1234' },
      { name: 'MyCorp LLC', oauth: { token: 'asdfasdf1234' } },
    ];

    let sanitizeCallback = (obj, path, value) => {
      delete obj[path[path.length - 1]];
    };

    traverse(users, sanitizeCallback, [/password/, '*token']);

    console.log(users);

    // [ { name: 'Josh' },
    //   { name: 'Matej' },
    //   { name: 'Elisia' },
    //   { name: 'Jonas' },
    //   { name: 'Lasse' },
    //   { name: 'MyCorp LLC', oauth: {} } ]

Testing
=======

    $ npm i -g mocha

    $ npm test

    ...

    16 passing (10ms)

License
=======

The MIT License (MIT)

Copyright (c) 2019 Joshua Jung

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.

repository: joshjung/traverse-object

repo_name: joshjung/traverse-object


text:
---
Title: Windows Community Toolkit
Contributor: Microsoft
Logo: microsoft.jpg
Web: https://www.microsoft.com
---
# Windows Community Toolkit

The [Windows Community Toolkit](https://aka.ms/windowstoolkit) is a collection of helper functions, custom controls, and app services. It simplifies and demonstrates common developer tasks building experiences for Windows 10 and .NET.

## Project Details

* [Source](https://aka.ms/windowstoolkit)
* [Sample App](https://aka.ms/windowstoolkitapp)
* [Getting Started](https://docs.microsoft.com/windows/communitytoolkit/getting-started)
* License: [MIT](https://github.com/windows-toolkit/WindowsCommunityToolkit/blob/master/license.md)
* Project Leads: [Michael A. Hawker aka XAML Llama](https://twitter.com/XAMLLlama)

## Quicklinks

* [Documentation](https://aka.ms/windowstoolkitdocs)
* Discussions can be held on [UWP Community Discord](https://discord.gg/zBA5aCn)
* [Contribution Guide](https://aka.ms/wct/wiki)

repository: dotnet-foundation/website

gha_language: HTML

repo_name: dotnet-foundation/website


text:
---
Title: Cory House
Location: Kansas City, USA
Email<EMAIL_ADDRESS>Language:
  - English
Topics:
  - .NET
  - ASP.NET
  - C#
  - JavaScript
  - macOS
  - Visual Studio
  - Visual Studio Code
  - Web Development
Blog: https://www.bitnative.com
Twitter: https://www.twitter.com/housecor
GitHub: https://www.github.com/coryhouse
StackOverflow: https://stackoverflow.com/users/26180/cory-house
LinkedIn: https://www.linkedin.com/in/coryhouse/
---
I've been writing JavaScript since the days of Netscape. I've specialized in React since shortly after it was launched, and have partnered with teams around the globe to ship dozens of significant React projects. I've authored multiple courses on C#, React, and JavaScript that have been viewed by over 500,000 developers worldwide. I've trained over 10,000 developers in person, while leading 100's of sessions at businesses and conferences across the USA and internationally.


text:
# Parking Now

Project for: **COGS 120 / CSE 170**

Collaborators: **Steven Tran, Angela Liu, Chiao Wang**

Park Now is a mobile web app design to assist UCSD students in the horrendous task known as parking

**Project Description**

This is a parking assistant application aimed to help UCSD students more quickly find
parking on campus.

This application logs users in using TritonLink SSO, so it has access to user's
current class schedules.

It allows users to view current parking conditions across all parking lots and
parking structures on campus in real-time.

Users can enable notifications on a parking area of their choice to recieve updates
as to when parking lots are filling up or are full.

Users also have the ability to set reminders for when to leave their home in the
morning to guaruntee parking on campus.

**Pages with completed HTML**

* [x] welcome screen
* [x] login screen
* [x] permit adding screen
* [x] index - homepage
* [x] reminders screen
* [x] reminder adding screen
* [x] settings screen
* [x] help screen
* [ ] full parking alert
* [ ] reminder alert

**Notes**

Need to edit the CSS to be used correctly on mobile sites.

Need to also make the buttons and links consistent

Need to make sure all the buttons and tabs on the bottom stay static when scrolling


text:
## 1.2.3
* Added the ActivityType class
* Updated example app
* Updated docs

## 1.2.2
* Updated Android permissions in docs
* Removed table from README since it was broken on pub.dev

## 1.2.0
* Changed package name to `dk.cachet.activity_recognition_flutter`

## 1.1.0
* Updated documentation with the link to https://github.com/flutter/flutter/wiki/Upgrading-pre-1.12-Android-projects

## 1.0.0
* Initial re-implementation

gha_language: Dart


text:
# RSSAggro

This is a simple rss aggregator written with Flask, React and Redux.
Initially the project was part of an assignment in *TIEA2080 Web server development* course.

View example app at [https://tiea2080-vt7.appspot.com/](https://tiea2080-vt7.appspot.com/).

## Project structure

* rss_api --> Python backend
* app --> JavaScript frontend
* app.yaml --> Configuration of routes for Google App Engine
* requirements.txt --> Python requirements

## Some notes on choice of tools

* No webpack! All frontend bundling is done with Parcel (https://parceljs.org/) that requires zero configuration!
* CSS is made mainly with Tailwind CSS (https://tailwindcss.com/) -- no pre-made frameworks!
* The frontend is made with React for the UI and Redux for app state + AJAX.
    * Technically it's not really AJAX, since I use the newer (and much better) Fetch API.

## Running the code locally

If you want to run the development server locally, you will need:

* Google Cloud SDK (I used the newest one with `gcloud` command, but the older one might work as well)
* Python 2.7 + virtualenv (install via `pip`)
* Node.JS 8.9.3 (might also work with other versions as well)
* NPM 5.6.0 (or newer)

Steps to set up:

#### Python part:

1. Open the console in this directory
2. Run `virtualenv env` to set up Python's virtualenv in `env` folder
3. Run `./env/Scripts/activate.bat` to activate virtual environment
4. Run `pip install -r requirements.txt -t lib` to install needed Python requirements into `lib` folder
5. Run `dev_appserver.py app.yaml` to launch the development server

The server should pop up on ports 8080 and 8000.

#### JavaScript part:

1. Open the console in `app` directory
2. Run `npm install` to install all dependencies
3. Run `npm run watch` to launch the development environment in watch mode

Now you can go to `localhost:8080`. If everything worked fine, you should see the app there.
Editing the application source will update the server and the output.

If you want to build the final minified application, run `npm run build`.

repository: dezhidki/rss-aggro

repo_name: dezhidki/rss-aggro


text:
## Authentication
 - [x] Basic
 - [x] Oauth
    - [ ] Scope
    - [ ] Automated client registration
 - [ ] 3rd party (Google, Facebook, Twitter, Steam, reddit, etc.)
 - [ ] Account creation page
 - [ ] Account creation API
 - [ ] 2 factor authentication

## Rooms
 - [x] Room creation
 - [x] Send messages
 - [x] Add users

## Account preferences
 - [x] Preferences model
 - [ ] Preferences API (excluding password change]
 - [ ] Password change page
 - [ ] Friends
 - [ ] Blocked users
 - [ ] Linked phone number

## Push notifications
 - [ ] GCM
 - [ ] APNS
 - [ ] MPNS

## API keys
 - [ ] API keys
 - [ ] Automated API key registration

## Misc
 - [ ] Rename project to more user-friendly name
 - [ ] Write API docs
 - [ ] Develop a uniform coding style

repository: gradymcd/MessageAPI

repo_name: gradymcd/MessageAPI


text:
# Description

An express template for web apps.

# Instructions

```
You will create two config files.  A config JSON for the server with the following fields:
{
    "PORT": <Port Number>,
    "API_ROUTER": "<./pathToYourRoutingFile.j>",
    "API_PATH": "</endpointAPI/path>"
}
```

as well as a path for your database setup
Note: Make sure to set multipleStatements to true if you have more than one table you are making.

```
{
    "config": {
        "mySQLHost": "<Hostname of the MySQL server>",
        "mySQLUsername": "<Username you'll use to connect to the MySQL server>",
        "mySQLPassword": "<Password you'll use to connect to the MySQL server>",
        "databaseName": "<Name of the DB you'll use for this webapp>"
        "multipleStatements": <true/false depending on if you have multiple tables below to setup>
    },
    "tables": [
        {
            "tableName": "table1",
            "schema": {
                "field1": "VARCHAR(100) PRIMARY KEY",
                "field2": "VARCHAR(100)"
            }
        },
        {
            "tableName": "table2",
            "schema": {
                "field1": "VARCHAR(100) PRIMARY KEY",
                "field2": "VARCHAR(100)"
            }
        }
    ]
}
```

Customize the files to fit your needs, but generally should only have to work in the router file.
Examples of how to use it are included for get/post/delete methods.

# Change Log

## V1.0 | Initial Version | 8e14caa

repository: MarkBrosche/hifi-content

repo_name: MarkBrosche/hifi-content


text:
OCaml Library Standard
======================

This repository defines a standard describing how OCaml libraries should
be organised and described once installed on the system. It aims to
allowing various tools & libraries such as `dune`, `ocamlfind` and
`findlib` to interoperate nicely and also to allow authors of OCaml
tools to make safe assumption when they need to use installed
OCaml libraries.

Contacts:
- Jeremie Dimino (@dim)
- Gerd Stolpmann (@gerdstolpmann)

*Status:* the initial specification being developed between `dune` and
`ocamlfind`.

repository: Global-localhost/ocaml-library-standard

repo_name: Global-localhost/ocaml-library-standard


text:
MrChecker template - parent pom
---------------
This is the parent pom. It's a place where you should collect dependencies common for your subprojects, common profiles.

#### How to version it?
Semantic versioning.
#### How to make maven to use the newest version?
Maven is discuraging use of LATEST keyword so the resonable solution is to use range [1.0.0,2.0.0), so major version 1 and as we know from semantic versioning if there is change in major version number there is compatibility break anyways.
#### How to deploy it?
Create special jenkins job for it or if you have a credentials that allow writing to nexus you can do it with mvn.

repository: devonfw/mrchecker

branch_name: refs/heads/develop

repo_name: devonfw/mrchecker


text:
# SwiftFeatures

This playground contains interesting features of Swift that I find while using it. The list is intended to be updated in future.

Contents:

1. Var in for-in loop
2. Property observers for local variables
3. ~= operator
4. Curried functions

If you have something you'd like to share, pull requests are welcome.

repository: ilyapuchka/SwiftFeatures

repo_name: ilyapuchka/SwiftFeatures


text:
# Portfolio

This website's purpose is to demonstrate my abilities in creating a webpage while also showing the user my contact information and portfolio. This project was centered around ReactJS.

## Description

Some fun features of this website:

* A resume displayed as a png that is also downloadable as a pdf
* A collapsible navbar for mobile browsing
* Lots of FABs featuring Font Awesome Icons
* Cards presenting my various projects
* Hover effects
* Tooltips for all buttons

## Built With
* [ReactJS](https://reactjs.org/)
* [Materialize CSS](https://materializecss.com/)
* [JQuery](https://jquery.com/)
* [Font Awesome](https://fontawesome.com/)
* [Favicon](https://favicon.io/)
* [Animate on Scroll](https://michalsnik.github.io/aos/)

## Link to Site

[Click to access my Portfolio!](http://paul-vatterott.com/React-Portfolio/#/)

## Screenshots
![screenshot](./src/assets/images/screenshot1.png)

![site in action](./src/assets/images/screenshot2.png)

![graphs](./src/assets/images/screenshot3.png)

## Authors

### Paul Vatterott
[Github](https://github.com/pfvatterott)

Email<EMAIL_ADDRESS>
## License
MIT License

Copyright (c) 2021 Paul Vatterott

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.

repository: pfvatterott/React-Portfolio

repo_name: pfvatterott/React-Portfolio


text:
# Internal Apple bundling logic

The `.bzl` files in this directory are internal implementation details for the
Apple bundling rules. They should not be imported directly by users; instead,
import the platform-specific rules in `//apple:ios.bzl`, `//apple:tvos.bzl`,
and so forth.

As a matter of style, files ending in `_actions.bzl` export modules with
functions that register specific actions (such as compiling Interface Builder
files with `ibtool`), whereas files ending in `_support.bzl` export modules
with general support functions (most of which do not register actions, but some
of which do in a generic sense, such as `xcode_env_action` in
`platform_support`). This separation helps to avoid circular dependencies in
Skylark `load` statements (because actions are only registered in one place,
but support functions may be needed in multiple places throughout the bundling
codebase).


text:
### Table of Contents

1. [Overview](#Overview)

2. [Minimum Recommended Skillset](#MinSkillset)

3. [Required Reading](#ReqReading)

4. [Development Practices](#DevelopmentPractices)

   4.1. [Share Early, Share Often](#ShareEarly)

   4.2. [Testing](#Testing)

   4.3. [Code Documentation and Commenting](#CodeDocumentation)

   4.4. [Model Git Commit Messages](#ModelGitCommitMessages)

5. [Code Approval Process](#CodeApproval)

   5.1 [Code Review](#CodeReview)

   5.2 [Rework Code (if needed)](#CodeRework)

   5.3 [Acceptance](#CodeAcceptance)

6. [Contribution Standards](#Standards)

   6.1. [Contribution Checklist](#Checklist)

   6.2. [Licensing of Contributions](#Licensing)

### 1. Overview

Developing cryptocurrencies is an exciting endeavor that touches a wide variety of areas such as wire protocols,
peer-to-peer networking, databases, cryptography, language interpretation (transaction scripts), RPC, and websockets.
They also represent a radical shift to the current fiscal system and as a result provide an opportunity to help reshape
the entire financial system. There are few projects that offer this level of diversity and impact all in one code base.

However, as exciting as it is, one must keep in mind that cryptocurrencies represent real money and introducing bugs and
security vulnerabilities can have far more dire consequences than in typical projects where having a small bug is
minimal by comparison. In the world of cryptocurrencies, even the smallest bug in the wrong area can cost people a
significant amount of money. For this reason, the pod suite has a formalized and rigorous development process which is
outlined on this page.

We highly encourage code contributions, however it is imperative that you adhere to the guidelines established on this
page.

### 2. Minimum Recommended Skillset

The following list is a set of core competencies that we recommend you possess before you really start attempting to
contribute code to the project. These are not hard requirements as we will gladly accept code contributions as long as
they follow the guidelines set forth on this page. That said, if you don't have the following basic qualifications you
will likely find it quite difficult to contribute.

- A reasonable understanding of bitcoin at a high level (see the [Required Reading](#ReqReading) section for the
  original white paper)

- Experience in some type of C-like language. Go is preferable of course.

- An understanding of data structures and their performance implications

- Familiarity with unit testing

- Debugging experience

- Ability to understand not only the area you are making a change in, but also the code your change relies on, and the
  code which relies on your changed code

Building on top of those core competencies, the recommended skill set largely depends on the specific areas you are
looking to contribute to. For example, if you wish to contribute to the cryptography code, you should have a good
understanding of the various aspects involved with cryptography such as the security and performance implications.

### 3. Required Reading

- [Effective Go](http://golang.org/doc/effective_go.html) - The entire pod suite follows the guidelines in this
  document. For your code to be accepted, it must follow the guidelines therein.

- [Original Satoshi Whitepaper](http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCkQFjAA&url=http%3A%2F%2Fbitcoin.org%2Fbitcoin.pdf&ei=os3VUuH8G4SlsASV74GoAg&usg=AFQjCNEipPLigou_1MfB7DQjXCNdlylrBg&sig2=FaHDuT5z36GMWDEnybDJLg&bvm=bv.59378465,d.b2I)
  - This is the white paper that started it all. Having a solid foundation to build on will make the code much more
  comprehensible.

### 4. Development Practices

Developers are expected to work in their own trees and submit pull requests when they feel their feature or bug fix is
ready for integration into the master branch.

### 4.1 Share Early, Share Often

We firmly believe in the share early, share often approach. The basic premise of the approach is to announce your
plans **before** you start work, and once you have started working, craft your changes into a stream of small and easily
reviewable commits.

This approach has several benefits:

- Announcing your plans to work on a feature **before** you begin work avoids duplicate work

- It permits discussions which can help you achieve your goals in a way that is consistent with the existing
  architecture

- It minimizes the chances of you spending time and energy on a change that might not fit with the consensus of the
  community or existing architecture and potentially be rejected as a result

- Incremental development helps ensure you are on the right track with regards to the rest of the community

- The quicker your changes are merged to master, the less time you will need to spend rebasing and otherwise trying to
  keep up with the main code base

### 4.2 Testing

One of the major design goals of all core pod packages is to aim for complete test coverage. This is financial software
so bugs and regressions can cost people real money. For this reason every effort must be taken to ensure the code is as
accurate and bug-free as possible. Thorough testing is a good way to help achieve that goal.

Unless a new feature you submit is completely trivial, it will probably be rejected unless it is also accompanied by
adequate test coverage for both positive and negative conditions. That is to say, the tests must ensure your code works
correctly when it is fed correct data as well as incorrect data (error paths).

Go provides an excellent test framework that makes writing test code and checking coverage statistics straight forward.
For more information about the test coverage tools, see the [golang cover blog post](http://blog.golang.org/cover).

A quick summary of test practices follows:

- All new code should be accompanied by tests that ensure the code behaves correctly when given expected values, and,
  perhaps even more importantly, that it handles errors gracefully

- When you fix a bug, it should be accompanied by tests which exercise the bug to both prove it has been resolved and to
  prevent future regressions

### 4.3 Code Documentation and Commenting

Comments have a way of turning into lies during development, you should not expect readers to depend on it. Much more
important is that names are meaningful, they do not take up excessive space, and comments are only necessary when the
meaning of the code needs clarification.

- At a minimum every function must be commented with its intended purpose and any assumptions that it makes

    - Function comments must always begin with the name of the function
      per [Effective Go](http://golang.org/doc/effective_go.html)

    - Function comments should be complete sentences since they allow a wide variety of automated presentations such
      as [godoc.org](https://godoc.org)

    - Comments should be brief, function type signatures should be informative enough that the comment is for
      clarification. Comments are not tested by the compiler, and can obscure the intent of the code if the code is
      opaque in its semantics.

    - Comments will be parsed by godoc and excess vertical space usage reduces the readability of code, so there is no
      sane reason why the comments (and indeed, in documents such as this) should be manually split into lines. That's
      what word wrap is for.

    - The general rule of thumb is to look at it as if you were completely unfamiliar with the code and ask yourself,
      would this give me enough information to understand what this function does and how I'd probably want to use it?

    - Detailed information in comments should be mainly in the type definitions. Meaningful names in function parameters
      are more important than silly long complicated comments and make the code harder to read where the clarity is most
      needed.

    - If you need to write a lot of comments about code you probably have not written it well.

    - Variable and constant names should be informative, and where obvious, brief.

    - If the function signature is longer than 80 characters in total, you should change the parameters to be a
      structured variable, the structure will explain the parameters better and more visually attractive than a function
      call with more than 5 parameters.

    - If you use a constant value more than a few times, and especially, in more than a few source files, you should
      give it a meaningful name and place it into separate folders that allows you to avoid circular dependencies. It is
      better to define a type independently, and create an alias in the implementation as methods must be defined
      locally to the type. However, if you need to access the fields of the type, the definition needs to be isolated
      separate from the implementation, otherwise you almost certainly will run into a circular dependency that will
      block compilation.

    - The best place for detailed information is a separate `doc.go` file, where the comment that appears before the
      package name appears at the very top in the Godoc output, and in the structure and type definitions for exported
      types. Functions should not be the place to put this, as it interferes with readability, and scatters the
      information, at the same time.

### 4.4 Model Git Commit Messages

This project prefers to keep a clean commit history with well-formed commit messages. This section illustrates a model
commit message and provides a bit of background for it. This content was originally created by Tim Pope and made
available on his website, however that website is no longer active, so it is being provided here.

Here’s a model Git commit message:

```
Short (50 chars or less) summary of changes

More detailed explanatory text, if necessary.  Wrap it to about 72
characters or so.  In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body.  The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.

Write your commit message in the present tense: "Fix bug" and not "Fixed
bug."  This convention matches up with commit messages generated by
commands like git merge and git revert.

Further paragraphs come after blank lines.

- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, preceded by a
  single space, with blank lines in between, but conventions vary here
- Use a hanging indent
```

Prefix the summary with the subsystem/package when possible. Many other projects make use of the code and this makes it
easier for them to tell when something they're using has changed. Have a look
at [past commits](https://github.com/p9c/pod/commits/master) for examples of commit messages.

### 5. Code Approval Process

This section describes the code approval process that is used for code contributions. This is how to get your changes
into pod.

### 5.1 Code Review

All code which is submitted will need to be reviewed before inclusion into the master branch. This process is performed
by the project maintainers and usually other committers who are interested in the area you are working in as well.

##### Code Review Timeframe

The timeframe for a code review will vary greatly depending on factors such as the number of other pull requests which
need to be reviewed, the size and complexity of the contribution, how well you followed the guidelines presented on this
page, and how easy it is for the reviewers to digest your commits. For example, if you make one monolithic commit that
makes sweeping changes to things in multiple subsystems, it will obviously take much longer to review. You will also
likely be asked to split the commit into several smaller, and hence more manageable, commits.

Keeping the above in mind, most small changes will be reviewed within a few days, while large or far reaching changes
may take weeks. This is a good reason to stick with the [Share Early, Share Often](#ShareOften) development practice
outlined above.

##### What is the review looking for?

The review is mainly ensuring the code follows the [Development Practices](#DevelopmentPractices)
and [Code Contribution Standards](#Standards). However, there are a few other checks which are generally performed as
follows:

- The code is stable and has no stability or security concerns
- The code is properly using existing APIs and generally fits well into the overall architecture
- The change is not something which is deemed inappropriate by community consensus

### 5.2 Rework Code (if needed)

After the code review, the change will be accepted immediately if no issues are found. If there are any concerns or
questions, you will be provided with feedback along with the next steps needed to get your contribution merged with
master. In certain cases the code reviewer(s) or interested committers may help you rework the code, but generally you
will simply be given feedback for you to make the necessary changes.

This process will continue until the code is finally accepted.

### 5.3 Acceptance

Once your code is accepted, it will be integrated with the master branch. Typically it will be rebased and fast-forward
merged to master as we prefer to keep a clean commit history over a tangled weave of merge commits. However,regardless
of the specific merge method used, the code will be integrated with the master branch and the pull request will be
closed.

Rejoice as you will now be listed as a [contributor](https://github.com/p9c/pod/graphs/contributors)!

### 6. Contribution Standards

### 6.1. Contribution Checklist

- [  ] All changes are Go version 1.11 compliant

- [  ] The code being submitted is commented according to
  the [Code Documentation and Commenting](#CodeDocumentation) section

- [  ] For new code: Code is accompanied by tests which exercise both the positive and negative (error paths)
  conditions (if applicable)

- [  ] For bug fixes: Code is accompanied by new tests which trigger the bug being fixed to prevent
  regressions

- [  ] Any new logging statements use an appropriate subsystem and logging level

- [  ] Code has been formatted with `go fmt`

- [  ] Running `go test` does not fail any tests

- [  ] Running `go vet` does not report any issues

- [  ] Running [golint](https://github.com/golang/lint) does not report any **new** issues that did not
  already exist

### 6.2. Licensing of Contributions

All contributions must be licensed with the [ISC license](https://github.com/p9c/pod/blob/master/LICENSE). This is the
same license as all of the code in the pod suite.

license: Unlicense,ISC

repository: marcetin/parallelcoin

detected_licenses: Unlicense ISC

gha_license_id: NOASSERTION

repo_name: marcetin/parallelcoin


text:
# Lambda Bundler

![Lambda-Bundler-Build](https://github.com/MauriceBrg/lambda_bundler/workflows/Lambda-Bundler-Build/badge.svg?branch=master)
[![Maintainability](https://api.codeclimate.com/v1/badges/d8e6323930db603aad30/maintainability)](https://codeclimate.com/github/MauriceBrg/lambda_bundler/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/d8e6323930db603aad30/test_coverage)](https://codeclimate.com/github/MauriceBrg/lambda_bundler/test_coverage)
[![PyPI version](https://badge.fury.io/py/lambda-bundler.svg)](https://badge.fury.io/py/lambda-bundler)
![License](https://img.shields.io/pypi/l/lambda-bundler)
![PythonVersions](https://img.shields.io/pypi/pyversions/lambda-bundler)

Lambda Bundler helps you package your python lambda functions and their dependencies for deployment to AWS.

It supports three different modes:

- Package dependencies for a Lambda layer
- Package code-only dependencies from multiple directories for deployment to Lambda
- Package your own code and external dependencies into a single zip for deployment to Lambda

Dependencies will be cached if possible in order to provide a fast build experience.

## Installation

The installation is very simple using pip:

```text
pip install lambda-bundler
```

## How to use

### Package a Lambda layer

```python
from lambda_bundler import build_layer_package

path_to_deployment_artifact = build_layer_package(
    # You can install the dependencies from multiple
    # requirement files into a single layer
    requirement_files=[
        "path/to/requirements.txt"
    ]
)

# path_to_deployment_artifact now points to a zip archive with the dependencies.
```

### Package code directories

```python
from lambda_bundler import build_lambda_package

path_to_deployment_artifact = build_lambda_package(
    code_directories=[
        "path/to/package",
        "path/to/other/package
    ],
    exclude_patterns=[
        "*.pyc"
    ]
)

# path_to_deployment_artifact now contains the path to the zip archive
```

### Package code directories and dependencies

If you'd like to package your dependencies directly into the deployment artifact you can do that very easily. Please keep in mind, that the size limit for a zipped deployment package is 50MB according to the [documentation](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) and the content of packages larger than 3MB won't be visible in the code editor in the console.

```python
from lambda_bundler import build_lambda_package

path_to_deployment_artifact = build_lambda_package(
    code_directories=[
        "path/to/package",
        "path/to/other/package
    ],
    requirement_files=[
        "path/to/requirements.txt
    ],
    exclude_patterns=[
        "*.pyc"
    ]
)

# path_to_deployment_artifact now contains the path to the zip archive
```

## Configuration

The library uses a working directory to build and cache packages.
By default this is located in the `lambda_bundler_builds` folder in your temporary directory as determined by [python](https://docs.python.org/3/library/tempfile.html#tempfile.gettempdir).

If you'd like to change that, you can set the `LAMBDA_BUNDLER_BUILD_DIR` environment variable and point it to another directory.

If you're using the Cloud Development Kit and just want to do a `cdk synth` to check your infrastructure code without actually deploying it, you can set the environment variable `LAMBDA_BUNDLER_SKIP_INSTALL` to `true`. This will skip installing dependencies and bundling the code, which makes the process a lot faster - although it won't work when you try to deploy it with the variable set to `true`.

## Demo / Example

For an example of how to use this, I suggest you check out the [demo repository](https://github.com/MauriceBrg/lambda-bundler-demo) which includes a CDK app that deploys three lambda functions with dependencies of different sizes.
If you take a closer look at the [build pipeline](https://github.com/MauriceBrg/lambda-bundler-demo/actions?query=workflow%3ALambda-Bundler-Demo-Build) you'll see, how effective the caching is.

## Known Limitations

- Packages are downloaded and built on your local machine, that means you might experience problems with libraries that use C-extensions if your platform is not Linux. Building packages with Docker is something I'd like to look into if there's a demand for that.
- Currently there's no warnings/errors if your deployment package surpasses the Lambda limits - if there's a need for that I'll consider adding those.
- This is built towards integration with the AWS CDK in python and doesn't work well standalone. I'm considering adding a CLI interface for use in Deployment Pipelines. Let me know if this is something you could use.


text:
# libdseed
This is base library for personal project.

![libdseed logo](./docs/logo.svg)

## Features
* SIMD Vector/Matrix Math Interface
* Reference Counting Object
* Stream/File-System Interface
* 100-nanoseconds based Timespan
* Bitmap Decoders/Encoders
* Bitmap Color-space Conversion
* Bitmap Flip/Crop/Arithmetic-Operation/Resize
* Audio Decoders/Encoders
* Audio PCM Data-type Conversion

## Goals
* Light-weight Cross-platform Game Engine Framework
* SIMD Bitmap/Audio Processing
* AVX2 Math Interface
* Implement Content Pipeline

repository: daramkun/libdseed

repo_name: daramkun/libdseed