text:
# faas
Lambda Function:This project is designed to trigger mail to reset password for users

## Getting Started

### Prerequisites
* Git
* JDK 8 or later
* Maven 3.0 or later

### Clone
To get started you can simply clone this repository using git:
```
git clone git@github.com:patroa-su2020/faas.git
```

### Build an executable JAR
You can run the application from the command line using:
```
mvn clean install
```
Or you can build a single executable JAR file that contains all the necessary dependencies, classes, and resources with:
```
mvn clean package
```
Then upload the jar file to S3 Bucket

*Instead of `mvn` you can also use the maven-wrapper `./mvnw` to ensure you have everything necessary to run the Maven build.*

## CI/CD
```$xslt
1 Trigger Circle CI build
2 The script builds the project and uploads the jar to s3 bucket
3 aws_lambda_function resource created through terraform make use of this jar file as a microservice
4 any payload on the SNS topic will trigger the lambda function
```

#How the lambda function works?
```
1 Once the user clicks on forgot password link:
2 A message(user email) is put on Amazon SNS topic
3 Lambda function subscribed to that topic, fetches the email address
4 Triggers an email to the desired address with a unique password reset link
```

This project is licensed under the terms of the [MIT license](LICENSE).

##Application Endpoints to access lambda function
```
http://<domain_name>/forgotpassword
```

repository: ankitpatro/faas

repo_name: ankitpatro/faas


text:
# WAActionSheetController
WAActionSheetController let you create actionsheet that similar to WhatsApp where you can input image and change label font.

## Installation

### CocoaPods

[CocoaPods](https://cocoapods.org) is a dependency manager for Cocoa projects. For usage and installation instructions, visit their website. To integrate WAActionSheetController into your Xcode project using CocoaPods, specify it in your `Podfile`:

```ruby
pod 'WAActionSheetController', '~> 0.1.2'
```

## Usage

```Swift
let alert = WAActionSheetController()
alert.addAction(title: "Do Action", titleTextColor: nil, titleFont: nil, icon: nil, iconColor: nil) { (action) in
    print("Clicked!")
}

alert.addSystemAction(title: "Cancel", style: .cancel, handler: nil)
self.present(alert, animated: true, completion: nil)
```

license: MIT

repository: carabina/WAActionSheetController

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: carabina/WAActionSheetController


text:
---
title: X-Cart
repo: xcart/xcart5
homepage: https://www.x-cart.com
demo: https://www.x-cart.com/shopping-cart-demo.html
language: PHP
framework: N/A
license: OSL-3.0
description: Free shopping cart software & solutions for high‑performing online stores.
---

X-Cart 5 is an eCommerce software, developed in cooperation with real merchants. It’s PHP/MySQL-driven open-source solution that can be used as a ready online shop or big marketplace with multiple vendors out of the box or as a powerful platform for your eCommerce project. With more than 300 integrations including marketing tools of all sorts, payment gateways, shipping and tax carriers it resolves various business cases and new useful features are regularly added. Furthermore its functionality can be easily extended or modified to meet particular business requirements. X-Cart gives wide opportunities for your business allowing you to sell any type of products (digital or physical goods, services or rentals) through various channels (eBay, Amazon, Facebook). It’s mobile ready and SEO-friendly and offers a robust bi-directional integration with Wordpress.

repository: eCommWar/eCommWar

gha_language: JavaScript

repo_name: eCommWar/eCommWar


text:
# BS-Components

## [Documentation](https://bs-components.github.io/)

BS-Components is a Web Component replacement for the jQuery bootstrap plugins.  It works across multiple JavaScript frameworks including Plain JS, React, Vue, and Angular.

BS-Components was written because of a frustration about how Bootstrap is implements differently in the different JavaScript Frameworks.  As web developers we know how to write HTML and the solutions for React, Angular, and Vue all put a layer between the developer and the HTML.  The main goal of BS-Components is to put the developer as close to writing plain html while retaining the functionality of the Bootstrap components.  The BS-Components are implemented the same way across the different technologies.

The BS-Components were designed to be as close to the Bootstrap jQuery plugin components as possible.  Except they have had attributes added so that framework props can be used to pass data to them and Because jQuery is not used the events that the Web Components use can be listened to using the normal JavaScript framework listeners.

Note: This project does not support browsers older than IE11.

See [documentation](https://bs-components.github.io/) for installation and getting started instructions

---

Built Using:

- [bootstrap css from v4.4.1](https://github.com/twbs/bootstrap/releases/tag/v4.4.1)
- [stencil](https://stenciljs.com/)

Tests Using:

- [testcafe](https://github.com/DevExpress/testcafe)

---

Status:

- [x] Documentation
- [x] Example projects - (Angular is still WIP)
- [x] tooltip - run tests using: `yarn test-bs-tooltip`
- [x] popover - run tests using: `yarn test-bs-popover`
- [x] button - run tests using: `yarn test-bs-button`
- [x] modal - run tests using: `yarn test-bs-modal`
- [x] dropdown - run tests using: `yarn test-bs-dropdown`
- [x] collapse - run tests using: `yarn test-bs-collapse`
- [x] alert - run tests using: `yarn test-bs-alert`
- [x] tab - run tests using: `yarn test-bs-tab`
- [x] scrollspy - run tests using: `yarn test-bs-scrollspy`
- [ ] toast - run tests using: `yarn test-bs-toast`
- [ ] carousel not planned currently but maybe later

For all of the other bootstrap components a web component solution is not needed because they can be done with normal html and css. Use the bootstrap webpage component documents.

Note: bootstrap forms do tend to use some javascript validation to show or hide tooltip helpers. These do not have methods that are provided by bootstrap.js so this project will not have web component counterparts.

repository: bs-components/bs-components

gha_language: TypeScript

gha_license_id: MIT

repo_name: bs-components/bs-components


text:
# Welcome to VectorChat repo! ![Logo](./Client_WPF/Assets/VectorChatLogo.png "VectorChat Logo")

## Quick start guide

### Client
#### Run:
1. [Download](https://github.com/vudeam/PL_messenger/releases "Project releases") the latest Client app build (**portable**, no build needed)
2. Run the `.exe` file **once** and close it. This creates `config.json` file in the same folder it was ran. The file should look something like that:
```
{
	"messageRequestTime": 200,
	"mainWindowHeight": 540.0,
	"mainWindowWidth": 960.0,
	"serverAddress": "http://localhost:8080",
	"enableFileAuth": false,
	"login": "",
	"password": ""
}
```
3. Now you need to specify URL and port (`:8080` in the defalt file) for the server. Notice that you do *not* need the terminating `/` at the end of URL
4. After that you may configure some Client defaults like window dimensions at startup and so on
5. Enjoy!
#### Build:

### Server


text:
# Date Ranger

A date picker for flutter apps to pick single dates and date ranges

## Usage

To use this package first add the dependency to you [pubspec.yaml] file
```yaml
dependencies:
  flutter:
    sdk: flutter
  date_ranger:
```

[Example](https://github.com/funyin/date_ranger/blob/master/lib/example/example.dart)

```dart
import 'package:date_ranger/date_ranger.dart';
import 'package:flutter/material.dart';

class TestPack extends StatefulWidget {
  @override
  _TestPackState createState() => _TestPackState();
}

class _TestPackState extends State<TestPack> {
  var initialDate = DateTime.now();
  var initialDateRange =
      DateTimeRange(start: DateTime.now(), end: DateTime.now());

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        body: Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        Container(),
        Padding(
          padding: const EdgeInsets.all(24),
          child:  DateRanger(
          initialRange: initialDateRange,
          onRangeChanged: (range) {
            setState(() {
              initialDateRange = range;
            });
          },
        ),
        )
      ],
    ));
  }
}
```

## Features
* Layout-agnostic: Conforms to any width by calculating its height internally
* Simple architecture: Built with default flutter architecture without depending on other state management packages
* Highly customisable:  Almost every thing can be changed including dimensions since dimensions are adjusted internally
* Picker types:  You can swap between a regular date picker and a date range picker easily.

***
[![BuyMeAShawrma.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1619907239535/KqJOyu-70.png)](https://www.buymeacoffee.com/funyinkash)


text:
I DESIGN
======

Introduction
------------
The goal of this project is to develop an integrated development environment for a
simplified version of the programming language Logo, named "SLogo". There are two main
design goals in mind for this project. First, we want to ensure that the back-end part
of the project (e.g. command parsing, function storage, control of the dataStorage) is
separated from the front-end part of the project (e.g. graphic display, handling of
user input). This will allow us to work on each half of the project independently, as
long as we spend time in the beginning carefully designing how these two halves of
the project need to interact. This is a part of our second design goal, to design an
API that is complete and well-defined, and flexible enough to handle future extensions.

In general, the front-end and back-end are completely closed off from one another. We
achieve this separation through implementation of the Model-View-Controller architecture.
User input is handled by a single controller class, which is also responsible for
sending signals between the various front-end components and the back-end. Each
component of the SLogo IDE is designed in its own class, to promote code modularity
and future extensibility (i.e. allow for future components to be added or current ones
to be edited with ease). Furthermore, the back-end is designed to be flexible through
use of abstract command classes to allow for easy addition of new rules and commands
in the future. The back-end is connected to the front-end through the use of Java's
Observer/Observable classes. In essence, objects in the Model are bound to their relevant
objects in the View, such that the GUI is updated automatically whenever objects in the
Model change.

Design Overview
---------------
We'll begin by describing the front-end, or "View", component of our project. SLogoGUI
is the main container class, and is responsible for maintaining the proper layout of
all other elements within the scene. The main element within the GUI is TurtleView,
which displays the dataStorage as it draws the commands passed into it. Every time the
dataStorage's state is updated in the back-end, TurtleView will automatically update as well,
through bindings to a TurtleState object in the Model. CommandEntryBox will be beneath, and
contains a text box for entering the SLogo commands, as well as a button for submitting
and a button for clearing the text. Across the top of the GUI will be ToolBar, a
which will contain options for the user to change, such as background color,
SLogo language, dataStorage image, etc. Along the right-side will be a panel with multiple
tabs for the user to select. One of these is StoredFunctionView, which will
contain a vertical list of any functions and variables that have been defined so far.
There will also be CommandHistoryView, which will contain previously entered commands,
as well as their result (e.g. with the proper error message in case the command was
not parsed correctly). Both CommandHistoryView and StoredFunctionView will be clickable,
such that the clicked function/command will be entered into the CommandEntryBox. Any
internal interactions between the various View elements will be set up through the
SLogoController class through the use of EventListeners/Handlers. For example,
SLogoController will create the appropriate ClickListener so that when a command in
StoredFunctionView is clicked, it is properly loaded in to the TextEntryBox.

The back-end, or "Model", component is mainly controlled by the SLogoModel class.
SLogoModel will be the only part of the Model that View sends information through,
helping to ensure that the back-end is completely independent of the front-end
implementation. SLogoModel contains a CommandParser class, which reads in a String of
command input, and determines the proper Commands to excecute through the use of
expression trees and regex parsing. Command will be an abstract class, with a single
abstract method doCommand() that will be overriden for each different SLogoCommand.
SLogoModel will execute these commands one-by-one.
Whenever the dataStorage is updated, a Turtle class will be responsible
for correctly updating the current position, orientation, etc. of the Turtle through
methods like move(), rotate(), etc. This will update position of an observable TurtleState
object. There will also be a FunctionStorage class for keeping track of the different
variables and functions that have been defined thus far.

Communication between the two components is relatively simple. The front-end only needs
one method of communication to the back-end, namely the submitCommandText(String text),
located within SLogoController. This method is executed whenever the user clicks the
submit button within CommandEntryBox. Upon calling this method, the Model will first
parse the text, and then SLogoModel will execute the commands one-by-one. TurtleState will
be bound to TurtleView, just as FunctionStorage will be bound to StoredFunctionView, ensuring
that GUI elements are appropriately updated as their related Model elements change.
If an error is encountered, it will be thrown by Model, and dealt with by SLogoController
(e.g. CommandHistory will store the command in Red and display the error message).

![relationship between classes](MVC_model_draw.jpg)

User Interface
--------------
Overall, the user interface (UI) will be structures as rearrangable boxes within a main scene.
Each component of the UI will have domain over a specific Group it is given, and must stay
within the specified dimensions of that Group. Ideally within each Group, each element will
be placed relative to the given dimensions, rather than absolutely. This will allow us to
resize and rearrange each element of the UI at will, and therefore will allow us to add any
new front-end user-enabled features as necessary. The goal is to have GUI elements that can
function independently (other than the events that need to be sent between them), to allow
for easy flexibility in design.

As described in the previous section "Design Overview", the UI will contain several elements
with which the user may interact and use to view the results of their actions. Please see the
image included below for currently proposed placement of each view element, and see the section
above for the rest of the UI description.

The user may enter valid commands into the CommandEntryBox. Regardless of the result and
correctness of the command, it will then immediately show up in the CommandHistoryView.
The use of the CommandHistoryView is similar to the Console window of the Eclipse IDE:
here, the user will see the previous (clickable) commands which they entered, as well as any possible
error messages which the commands may have triggered. Upon the user entering executable commands, the
dataStorage in the TurtleViewer will move to complete the commands, even if the commands end in a command
that may throw an error.

![GUI](view_draw.jpg)

API Details
-----------
**View (Internal)**
* SLogoController
  * Various EventListeners
* SLogoView
  * CommandEntryBox
    * getCommandText()
  * ToolBar
  * TurtleView
    * draw()
  * HelperPanel
    * StoredFunctionView
      * getClickedFunction()
    * CommandHistoryView
      * getClickedCommand()

**View (External)**
* SLogoController
  * submitCommandText(String text)
  * submitLanguage(String language)

**Model (Internal)**
* CommandMaker
	* parseText(String str); returns commandTree
    * createCommands(commandTree); returns commandsQueue
* CommandExecutor
	* execute(Command[?] cmd); returns commandReturn
* Turtle
	* updateTurtle()

**Model (External)**
* SLogoModel
	* TurtleState
    * FunctionStorage
    * ErrorFlagger
    	* setErrorFlag(String errorType)

API Example Code
----------------
1. User types in fd 50
User types into the text box within CommandEntryBox and then clicks the Submit button within it.
Clicking the submit button triggers an EventListener created within SLogoController
(submitButtonListener). This listener calls getCommandText() within CommandEntryBox to return the
String of text entered. SLogoController then calls submitCommandText, which passes the text to
SLogoModel and prints the command to CommandHistory. SLogoModel parses the text, and then executes the
Commands in order, at a specific rate. As TurtleView and/or FunctionStorage are updated by these commands,
the related View classes are updated as well, through binding.
2. View Internal Example: User clicks on a function in the FunctionStorageView
A ClickListener (reated by SLogoController is triggered by the click). SLogoController determines that
FunctionStorageView is currently active (rather than CommandHistoryView), and passes the x, y coordinates
of the click to getClickedCommand() within FunctionStorageView. This returns the String name of the function
which is placed within CommandEntryBox through a setText() method.
3. View External Example: User sets a new language through the toolbar.
User clicks on the select language section of the toolbar, which opens a ComboBox for them to select a language.
Once they click the language, a ChangeListener (languageListener) within SLogoController will receive the newly
selected language, and call setLanguage(). This will in turn tell SLogoModel to call setLanguage within CommandParser,
to load the newly selected language resource.
4. Model Internal Example: `fd (fd 50)` is passed in as the string to parse.
parseText()--the command tree is made: fd -> fd -> 50. From this tree, createCommands() is called on the commandTree, and
the following list of commands is made: [fd50, fd50]. Where how the actual commands look will be determined later.
execute() is then called on the list of commands. One by one, each command is applied. If the command applies
to the Turtle, then updateTurtle() is called appropriately. Upon updating the Turtle, the TurtleState is updated
through binding.
5. Model External Example: the user enters the command `fs 50`.
parseText() is called on the command. The 'fs' cannot be matched to any existing pattern. This means
something is wrong with the command. parseText() throws an error, which is caught by the ErrorFlagger.
It then calls setErrorFlag(); upon setting, a listener from the controller sees that an errorFlag was raised.
The error message is passed to be displayed in the GUI.

Design Considerations
---------------------
The largest discussion we had over the design was simply what components should be part of the
back-end, and which components should be handled by the front-end or the controller. For instance,
the Turtle class is extremely important to both the Model and View components, so we had to figure
out the best way to make sure both parts had access to it. In the end, we decided that Turtle
belonged to the back-end, but that we would provide access to necessary variables through the use
of a TurtleState object. The goal when dividing the classes was to make sure that the Model could
function independently (i.e. nothing in the model logic was dependent on the implementation of the
View or Controller parts of the project).

Another consideration was how to tell the View to update the GUI with new information from Model.
We first considered simply letting SLogoController control updating of both the View and Model.
For example, SLogoController would tell the back-end to parse the given text and update appropriately,
and then would tell the GUI to update once the back-end was finished. However, this requires to much
communication between the SLogoController and the Model, so we decided to let the Model instead act
more independently, and the View to be updated through Java's Observable/Observer classes instead.

We also had difficulty determining how we actually want to represent commands that are parsed by
the Model. While the details still need to be hashed out, we decided it would be best to begin
with an overall abstract Command class, with a doCommand() method to be overriden by all subclasses.
We may create abstract subclasses of this Command class as well, such as TurtleCommand,
MathCommand, etc.

Finally, we had to consider how errors would be handled. We decided that in the case the Model
is provided with incorrect text to parse, it will throw the Error and stop parsing any more commands
from the submitted text. The error will be caught by the SLogoController, which will then be responsible
for communicating the exception to the GUI appropriately (i.e. display the error message to CommandHistory).

Team Responsibilities
---------------------
Will and James are working on the front-end, while Michael and Filip are working on the back-end.
We will meet again early next week to ensure that both teams are on the same page in terms of how
everything should interact, and then will mostly work on each component independently. Specific
responsibilities will be:

**Will**
Focus on the overall layout of the GUI classes and how they interact through SLogoView and SLogoController.

**James**
Focus on implementation of the individual GUI elements.

**Filip**
* Turtle
* Turtle State
* Controller Listener for Error

**Michael**
* Command Parsing
* Expression Tree
* Syntax errors


text:
# Umani!

## Entities

- Users [Students, Teachers, Staff, Admin, Super]
- Courses
- Page
- Quizzes
- Media
- Channels

## Sales Leads Registration

- Register candidates **sales process** [ui]

## User

- Add, Edit and Hide
- Assign role [student, teacher, staff, admin, super] or might be an Enum?
- Search?

## Collaboration

- Create channels
- Add Users
- Edit channels
- Post message in a Channels
- Edit post in a Channel
- Hide, Delete? post message
- Notification @user @group
- Repost (forward) message
- Private channels 1:1, 1:n
- Search inside post content
- List post by date in channel
  ```
    it should be able to paginate by time date given a n date should retrive
    a specific post plus past and future, this will depend on the scroller of the
    users. Similar like whatsapp, slack, discord handle it
  ```

## Groups

- Create groups by userId and TeacherId and StaffId
- Get group

## Content

### Quizzes

- Create Quizzes
- Version quizzes
- Support
  - Input Text,
  - Text Area,
  - Single Select and Multipe Select [Listbox, checkboxes, Image],
  - Fill the blank,
  - Relation right and left side
  - Sort questions
  - Close and open Quiz for assestment

### Pages

- Create Pages
- Append Page under a page (is recursive)
- Commit Pages
- Versioning Pages
- Store JSON page https://github.com/ianstormtaylor/slate
- embeded Quizzes
- embeded Media Image, Links, PDF, iframe (embbed) ex. youtube...

## Search

- Search student by [id, groupId, teacherId]

## Payment integration

- paypal stripe?

## Services

- upload media
- sent email/sms? to communicate with parents
- notification system
- who is connected (idle, online, offline) build presence https://firebase.google.com/docs/firestore/solutions/presence

## Steps

- Users **with roles**
- Courses `with versions?`
- Assign users to a course with roles
- Page `with versions?`
- Page under page **recursive**, `permission?`
- Asign pages to a course`permission?`
- **Service** Upload media pdf, images, etc...
- Content managment MVP
[Text, bold, align, strike, link, files (pdf, images, videos), underline, color, highlight, headers]
- b) Ability to Embeded images, videos, other artifacts, tweets, youtube, etc in a page
- Assigned pages to a course
- Publish a course
- List all courses
- Display the user progression from any given course
- Ability for an user to pay for a course or should pay a subscription or can we charge per course?
- Adding messages to the course like you do in papers documents or google docs
- Collaboration
- Quizzes
- Analytics

license: Unlicense

branch_name: refs/heads/main


text:
# docker-tf-helper

[![Docker Repository on Quay](https://quay.io/repository/synlay/tf-helper/status "Docker Repository on Quay")](https://quay.io/repository/synlay/tf-helper)

Docker Repository for the Terraform Helper tools

See [tf-helper](https://github.com/hashicorp-community/tf-helper) for more details.

## Custom Terraform Helper Plugins

* [queueplan](tfh_plugins/queueplan/tfh_queueplan.md) - Queues a plan for a workspace configured for remote execution

repository: mneumarkanaplan/docker-tf-helper

repo_name: mneumarkanaplan/docker-tf-helper


text:
Library Demonstration Programs      {#demos}
==============================

The demonstration programs provide examples of the usage of the library for a set of
supported boards. The examples show how to register a system with the library, and then
set-up and extract trace from the system. These programs and associated makefile are provided
in the `./demos` directory.

Board support is provided for a number of standard ARM platforms:-
- ST-Ericsson Snowball
- ARM Versatile Express Cortex-A15x2+A7x3 ("TC2")
- Juno (ARMv8-A development board), revisions r0 and r1.

Support for other platforms can be created by following the examples above to
create specific packages for the desired board.

The Example Programs
--------------------

The example programs provided are:-

- `csls`: A simple CoreSight list program that decodes a CoreSight ROM table and lists
the components found there.
- `cs_etm_config_demo`: A program demonstrating and printing the configuration of an ETM or PTM
component.
- `tracedemo`: A program to capture trace on a running linux system.
- `trace_cti_stop` : This captures trace on the running system in a similar way to tracedemo, but
uses the CTIs channels and triggers to inject a trigger-packet into the trace for each core, control
the trace generated by the cores, and trigger the ETB to flush and halt capture.

These programs can be built on a target system using the supplied  `makefile`.

The Example Source Code
-----------------------

The examples link to both the main CS Access library, and the CS Access Utility library.

The source example files provided are:-

- `cs_demo_known_boards.c` and `cs_demo_known_boards.h` : These files provide a list of known
   hardware boards for use in the demos. This list is passed to the CS Access Utility library
   `setup_board()` or `setup_named_board()` function.

- `csls.c` : main program source for the csls example.

- `cs_etm_config_demo.c` : main program source for the etm configuration demo.

- `tracedemo.c` : main program source for the trace capture demo.

- `tracedemo_cti_stop.c` : main program to trigger and stop trace capture using CTIs.

Using the Makefile
------------------

Running `make` in the `./demos` directory, or `make` in the project root directory  will build the default release
versions of all the demo programs. These will be created in the `../bin/<arch>/rel` output
directory, relative to `./demos`.
The build process links to the csaccess libraries built into the `../lib/<arch>/rel` directory.

When built from the project root directory, the demos are built with the same command line options as the main library.

By default `csls`, `tracedemo`, `etmdemo` and `trace_cti_stop` are built.

Individual programs can be built using the name of the program on the make command line if run in the ./demos directory.
When building individual demos, use the same make command line options as building the CSAL library.

e.g. The following command line builds the debug version of `tracedemo`

    make tracedemo DEBUG=1

Building and Running the TraceDemo Example
==========================================

This section covers the details for running the TraceDemo example on a supported board.
The set-up procedures here also apply to running any of the other examples on a target system.

Setting up the Example
----------------------

The sources are provided in `[DS-5 install dir]/examples/CoreSight_Access_Library.zip`.

First, import the example into the DS-5 Eclipse workspace as follows:
1. Launch Eclipse for DS-5.
2. Close the Welcome screen, if it appears.
3. From the **File** menu, select **Import...**. The Import wizard opens.
4. Open the **General** folder.
5. Select **Existing Projects into Workspace**
6. Press **Next**
7. Press **Browse...** next to **Select archive file:**. A file dialog opens.
8. Navigate to `[DS-5 install dir]\examples`, select `Coresight_Access_Library.zip`, then press 'OK'.
   The **Projects:** field populates with the project(s) found in the `.zip`.
9. Press **Finish**. The 'Project' view populates with the project(s).

Next, boot Linux on your target, login (preferably as root), and get the IP address of the target using `ifconfig`.
Then copy the `CoreSight_access` directory from the workspace to a suitable writable directory on your Linux target,
either using Remote System Explorer as provided in DS-5 or using a secure copy program such as `scp`
(Windows versions of this Linux command are available, such as `pscp` as provided with "Putty").

Configuring the Example for your Target
---------------------------------------

Before you can use the example on your target, you may have to modify some of the source files to suit your target:

- If your target is not one of the platforms already supported, then you will need to add a
  "registration" function into `cs_demo_known_boards.c`.
  To do this add an entry in the `known_boards[]` array, and write a suitable registration function.
- To configure the range of addresses to be traced in the kernel, open `tracedemo.c` and modify the values of:
  - `KERNEL_TRACE_SIZE` is the extent of the region to trace, and
  - `KERNEL_TRACE_VIRTUAL_ADDR` is the virtual address of the start of the region to trace, i.e. corresponding to addresses in the vmlinux file.
  If not set, it will default to the kernel load address plus 0x50000.

One way to identify the addresses of candidate regions/functions to trace is to use, for example:

    grep cpu_idle /proc/kallsyms

Configuring your Target for the Example
---------------------------------------

Before using the example on your target, check the following:

- For `tracedemo` to use `mmap` to read kernel memory (which it then dumps to a file `kernel_dump.bin` that can be read by DS-5 Debugger),
  the kernel must have been built without `CONFIG_STRICT_DEVMEM=y`.

  You can check this by typing:

      zgrep "CONFIG_STRICT_DEVMEM" /proc/config.gz

  If the kernel has been built with `CONFIG_STRICT_DEVMEM=y`, then you must either rebuild it with `CONFIG_STRICT_DEVMEM=n` or
  dump the kernel memory manually by some other means, for example, use DS-5 Debugger and DSTREAM to dump this kernel memory
  from the target (with, for example, the CLI command `dump memory kernel_dump.bin 0xC0008000 +0x50000`), or extract this kernel
  memory from the kernel Image file.

- For `tracedemo` to use `mmap()` to read kernel memory via `/dev/kmem`, the kernel must have been built with `CONFIG_DEVKMEM=y`.

- To view the disassembly and trace augmented with symbols (e.g. function names), the `vmlinux` file for the kernel must be available,
  built with debug symbols.  To map the trace and disassembly back to kernel source files, the kernel source tree must also be available.

  The `vmlinux` file with debug symbols is created when the kernel is built with debug info (`CONFIG_DEBUG_INFO=y`).  You can check
  how your kernel was built by typing:

      grep "CONFIG_DEBUG_INFO" /proc/config.gz

  If using `make menuconfig` to rebuild the kernel, select the following under 'Kernel Hacking':

      [*] Kernel debugging
          [*] Compile the kernel with debug info

Juno Platform - Additional Configuration when using the CSAL and Demos
----------------------------------------------------------------------
These are additional steps required on Juno systems to ensure correct operation of the CSAL.

The scripts mentioned below are shipped in the `demos/juno_demo_setup` directory.

__Preventing Core Power Down when Idle__

The Juno examples were built and tested on a Juno system that prevented the power down of idle cores.
This was to ensure that all the resources were accessible when the examples were run.

To achieve this:-

1) Create a file with the following contents with a suitable name (e.g. no_cpu_idle.sh).

    #!/bin/sh
    for i in 0 1 2 3 4 5; do
      for j in 0 1 2 ; do
        echo 1 > /sys/devices/system/cpu/cpu$i/cpuidle/state$j/disable;
      done;
    done

This can be run each time the system is booted. Alternatively, the following steps automate the process:-

2) Copy the file into `/etc/init.d/`

3) Run the following command to create an execute on boot link

    ln -s /etc/init.d/YOUR_FILE_NAME  /etc/rc5.d/S99_disable_cpuidle.sh

4) Reboot and confirm that idle is disabled by checking one of the cores (not core0)

    cat /sys/devices/system/cpu/cpu3/cpuidle/state1/disable

See [FAQ: Why am I having problems connecting a debugger to the Juno in DS-5?] (http://community.arm.com/docs/DOC-9320)

__Ensuring Debug Hardware Correctly Powered__

Early Juno system SCP firmware  had no way to power up the CoreSight debug hardware
without a request from an external debugger. This results in a hang when accessing the CoreSight ROM table and
other CoreSight hardware.

This has been corrected using firmware release for Linux kernel 4.9. (16.11 release package).

The workaround is to force a DAP power-up request on the application DAP by briefly attaching an external debug system.

The following script can be used with a DSTREAM connection in the CSAT tool shipped with DS-5 to power the DAPs.

    # Wake DAPS on a Juno system - allow CSAL to access CS debug hardware
    echo Powering Juno DAPs.

    # set the scan chain.
    chain dev=ARMCS-DP,ARMCS-DP

    # connect to first - will force power up
    dvo 0

    # check DP register for power ACK bits
    drr dp.csw

    dvc

    # connect to second - will force power up
    dvo 1

    # check DP register for power ACK bits
    drr dp.csw

    dvc

    echo Done

To use:-

1) Copy the script into a suitable file - e.g. `juno_wake_dap.cst`

2) Connect DSTREAM to your Juno board. Run the CSAT tool and connect to your DSTREAM.

3) On the CSAT command line type

    %> batch juno_wake_dap.cst

4) Disconnect CSAT and DSTREAM.

Running the demonstration example
---------------------------------

Run the `tracedemo` Linux application as root from the `.\bin\rel` directory:

    ./tracedemo

This will auto-detect the target board (if supported), configure trace generation, and retrieve trace
from the trace buffer.

If the board is not correctly detected then the following command line may be used:

    ./tracedemo -board-name Juno

The name parameter (Juno in this example) must match the `.hardware` structure element
in the `known_boards[]` array in the `cs_demo_known_boards.c` file.

To view the possible run options, add "-h" for help:

    ./tracedemo -h

You will see output like:

    Usage:
    -h      This help screen.
    -c <cpu>;        Select CPU for demo to run on. Default 0
    -itm    Enable ITM tracing, ITM tracing disabled by default.
    -full   Show full trace with no filtering.
    -pause  Run the demo with a pause after each step.

If you see: `** csaccess: ERROR: can't open /dev/mem`, then try running it as sudo:

    sudo ./tracedemo

You will see output like (for Snowball):

    root@linaro-ubuntu-desktop:/home/root/CoreSight_access# ./tracedemo
    Default configuration, no CPU affinity selected. ITM disabled.
    CoreSight demonstrator
    ** Currently affine CPUs: #0 #1
    CSDEMO: Detected 'ST-Ericsson Snowball platform' board
    CSDEMO: Registering Snowball CoreSight devices...
    801A4000: 1.2<PHONE_NUMBER>0 00/0F type= 7 - SINK BUFFER(8K)
    801A5000: 4.1<PHONE_NUMBER>0 00/0F type=10 - CTI
    801A6000: 2.1<PHONE_NUMBER>8 00/0F type= 4 - LINK
    801A8000: 5.1 C09 00000000 00/FF type=11 - CPU DEBUG v7 (full CP14) (4 wpt) (6 bkpt) non-Secure auth=AF
    801A9000: 6.1 9A0 00000000 00/FF type=12 - CPU PMU (6 counters) auth=8C
    801AA000: 5.1 C09 00000000 00/FF type=11 - CPU DEBUG v7 (full CP14) (4 wpt) (6 bkpt) non-Secure auth=AF
    801AB000: 6.1 9A0 00000000 00/FF type=12 - CPU PMU (6 counters) auth=8C
    801AC000: 4.1<PHONE_NUMBER>0 00/0F type=10 - CTI
    801AD000: 4.1<PHONE_NUMBER>0 00/0F type=10 - CTI
    801AE000: 3.1<PHONE_NUMBER>0 00/FF type= 1 - CPU SOURCE PTMv1.0
    801AF000: 3.1<PHONE_NUMBER>0 00/FF type= 1 - CPU SOURCE PTMv1.0
    CSDEMO: Registering CPU affinities...
    CSDEMO: Registering trace-bus connections...
    CSDEMO: Registration complete.
    CSDEMO: Configuring trace...
    CSDEMO: Configuring trace source id for CPU #0 ETM/PTM...
    CSDEMO: Initialising ETM/PTM
    ** 801AE000: write 030 (off) = 0000406F now 00000000
    ** 801AE000: write 150 (off) = 00000000 now 00020000
    CSDEMO: Configuring trace source id for CPU #1 ETM/PTM...
    CSDEMO: Initialising ETM/PTM
    ** 801AF000: write 030 (off) = 0000406F now 00000000
    ** 801AF000: write 150 (off) = 00000000 now 00020000
    ETM static configuration:
      ETMCCR = 8D294004
      ETMCCER = 000008EA
      ETMSCR = 00000000
      ETMIDR = 411CF301
    ETM dynamic configuration:
      ETMCR = 00000000
      Trace enable event: true
      Trace enable control: CR1=00000001 CR2=00000000
      Trace start comparators: 0000
      Trace stop comparators: 0000
      Counters: 2
        #0: value=00001000 enable=single-addr-comp-0 reload_value=00002000 reload_event=counter-zero-0
        #1: value=00001000 enable=sequencer-state-2 reload_value=00002000 reload_event=counter-zero-1
      Address comparators: 8
        #0: address=C0008000 type=00000019 (execute) (size=4) (S:all) (NS:all)
        #1: address=C0058000 type=00000019 (execute) (size=4) (S:all) (NS:all)
      Sequencer present: 1
      Sequencer:
        Current state: 1
        1 -> 2: single-addr-comp-0
        1 -> 3: false
        2 -> 1: false
        2 -> 3: single-addr-comp-1
        3 -> 1: false
        3 -> 2: false
    ** 801AE000: write 080 (CS_ETMACTR(i)) = 00000019 now 00000001
    ** 801AE000: write 084 (CS_ETMACTR(i)) = 00000019 now 00000001
    CSDEMO: Reading back configuration after programming...

    ETM static configuration:
      ETMCCR = 8D294004
      ETMCCER = 000008EA
      ETMSCR = 00000000
      ETMIDR = 411CF301
    ETM dynamic configuration:
      ETMCR = 00000400
      Cycle accurate: 0
      Branch output: 0
      Timestamp enabled: 0
      CONTEXTID size: 0 bytes
      Trace enable event: true
      Trace enable control: CR1=00000001 CR2=00000000
      Trace start comparators: 0000
      Trace stop comparators: 0000
      Trigger event: false
      Counters: 2
        #0: value=00001000 enable=single-addr-comp-0 reload_value=00002000 reload_event=counter-zero-0
        #1: value=00001000 enable=sequencer-state-2 reload_value=00002000 reload_event=counter-zero-1
      Address comparators: 8
        #0: address=C0008000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #1: address=C0058000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #2: address=B277380E type=00000D01 (execute) (size=1) (S:none) (NS:none)
        #3: address=E8FF4E39 type=00000D01 (execute) (size=1) (S:none) (NS:none)
        #4: address=989EAE80 type=00000801 (execute) (size=1) (S:all) (NS:none)
        #5: address=45FB31E5 type=00000F01 (execute) (size=1) (S:none) (NS:none)
        #6: address=E5F180E4 type=00000C01 (execute) (size=1) (S:none) (NS:none)
        #7: address=B6FD1362 type=00000301 (execute) (size=1) (S:all) (NS:all)
      Data comparators: 0
      Sequencer present: 1
      Sequencer:
        Current state: 1
        1 -> 2: single-addr-comp-0
        1 -> 3: false
        2 -> 1: false
        2 -> 3: single-addr-comp-1
        3 -> 1: false
        3 -> 2: false
      CONTEXTID comparators: 1
        Mask: FFFFFFFF
        #0: contextid: 00000000
      External outputs:
        #0: false
        #1: false
    CSDEMO: Enabling trace...
    CSDEMO: Configured and enabled trace.
    CSDEMO: Trace configured
    CSDEMO: Created trace configuration export files
    CSDEMO: trace buffer contents: 8192 bytes
    [press RETURN to stop tracing or q/Q to quit]
    CSDEMO: Disable trace...
    CSDEMO: trace buffer contents: 8192 bytes
    ETM static configuration:
      ETMCCR = 8D294004
      ETMCCER = 000008EA
      ETMSCR = 00000000
      ETMIDR = 411CF301
    ETM dynamic configuration:
      ETMCR = 10001400
      Cycle accurate: 1
      Branch output: 0
      Timestamp enabled: 1
      CONTEXTID size: 0 bytes
      Trace enable event: true
      Trace enable control: CR1=00000001 CR2=00000000
      Trace start comparators: 0000
      Trace stop comparators: 0000
      Trigger event: false
      Counters: 2
        #0: value=00001000 enable=single-addr-comp-0 reload_value=00002000 reload_event=counter-zero-0
        #1: value=00001000 enable=sequencer-state-2 reload_value=00002000 reload_event=counter-zero-1
      Address comparators: 8
        #0: address=C0008000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #1: address=C0058000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #2: address=6D7C9CB5 type=00000E01 (execute) (size=1) (S:none) (NS:none)
        #3: address=59425D80 type=00000C01 (execute) (size=1) (S:none) (NS:none)
        #4: address=FC1B425D type=00000401 (execute) (size=1) (S:none) (NS:all)
        #5: address=C085D159 type=00000B01 (execute) (size=1) (S:all) (NS:none)
        #6: address=CF79EACF type=00000801 (execute) (size=1) (S:all) (NS:none)
        #7: address=AB4DF605 type=00000B01 (execute) (size=1) (S:all) (NS:none)
      Data comparators: 0
      Sequencer present: 1
      Sequencer:
        Current state: 1
        1 -> 2: single-addr-comp-0
        1 -> 3: false
        2 -> 1: false
        2 -> 3: single-addr-comp-1
        3 -> 1: false
        3 -> 2: false
      CONTEXTID comparators: 1
        Mask: FFFFFFFF
        #0: contextid: 00000000
      External outputs:
        #0: false
        #1: false
    ETM static configuration:
      ETMCCR = 8D294004
      ETMCCER = 000008EA
      ETMSCR = 00000000
      ETMIDR = 411CF301
    ETM dynamic configuration:
      ETMCR = 10001400
      Cycle accurate: 1
      Branch output: 0
      Timestamp enabled: 1
      CONTEXTID size: 0 bytes
      Trace enable event: true
      Trace enable control: CR1=00000001 CR2=00000000
      Trace start comparators: 0000
      Trace stop comparators: 0000
      Trigger event: false
      Counters: 2
        #0: value=00001000 enable=single-addr-comp-0 reload_value=00002000 reload_event=counter-zero-0
        #1: value=00001000 enable=sequencer-state-2 reload_value=00002000 reload_event=counter-zero-1
      Address comparators: 8
        #0: address=C0008000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #1: address=C0058000 type=00000001 (execute) (size=1) (S:all) (NS:all)
        #2: address=B277380E type=00000D01 (execute) (size=1) (S:none) (NS:none)
        #3: address=E8FF4E39 type=00000D01 (execute) (size=1) (S:none) (NS:none)
        #4: address=989EAE80 type=00000801 (execute) (size=1) (S:all) (NS:none)
        #5: address=45FB31E5 type=00000F01 (execute) (size=1) (S:none) (NS:none)
        #6: address=E5F180E4 type=00000C01 (execute) (size=1) (S:none) (NS:none)
        #7: address=B6FD1362 type=00000301 (execute) (size=1) (S:all) (NS:all)
      Data comparators: 0
      Sequencer present: 1
      Sequencer:
        Current state: 1
        1 -> 2: single-addr-comp-0
        1 -> 3: false
        2 -> 1: false
        2 -> 3: single-addr-comp-1
        3 -> 1: false
        3 -> 2: false
      CONTEXTID comparators: 1
        Mask: FFFFFFFF
        #0: contextid: 00000000
      External outputs:
        #0: false
        #1: false
    CSDEMO: Fetching trace from core ETB:
      Buffer RAM size: 8192
      Bytes to read in buffer: 8192
      Buffer has wrapped: 1
    ** 8192 bytes of trace
    The first 256 bytes of trace are:
     80 01 AE D3 8E 01 4C 01 08 90 58 01 C0 29 CC 02  0C CA 00 9F FA 0C 48 01 08 E0 66 01 C0 29 EC 27
     A0 01 E6 C1 0E 68 02 08 9C 68 00 C0 28 D0 04 E6  AA D8 14 40 00 08 00 17 02 C0 28 CC 02 CC 02 65
     BE D8 14 60 00 08 A8 0C 00 C0 28 F4 02 AC F2 35  0C AE 88 08 94 89 02 C0 28 E8 02 AC A8 08 C4 38
     88 03 C0 29 DC 0B D6 8C 02 50 00 A9 84 01 70 69  00 F0 23 01 A0 FD 00 7C 00 C6 00 FB 8E 02 78 3D
     00 ED 18 6C 00 A4 EA 01 A0 E8 00 AC 08 74 18 25  00 C0 28 FC 08 A4 08 E0 66 01 C0 29 E0 AF 00 97
     E6 C1 0E 54 00 08 78 18 00 C0 28 C8 0C B4 08 37  E8 00 00 C0 28 FC 5A C4 02 08 BC 97 00 C0 28 9E
     F0 06 E2 18 58 01 F8 01 E4 03 EE AB 0A 28 08 62  0C 01 00 C0 28 E8 06 91 9E D1 00 1C 08 DC 48 BE
     04 C0 28 C8 BE 02 C4 05 08 FC 48 05 C0 29 DC 27  04 9C 98 0A 78 03 23 D3 D8 24 14 08 DC 49 04 8A
    CSDEMO: shutdown...

Depending on the configuration, `tracedemo` creates a number of output files such as `snapshot.ini`, `cpu_0.ini`, `cpu_1.ini`,
`device_2.ini`, `device_3.ini`, `trace.ini`, `kernel_dump.bin` and `cstrace.bin`.  These files can be loaded into DS-5 Debugger to analyze
the collected trace, as described in the next section.

Copy these files from the target into a suitable writable directory on your host, either using Remote System Explorer in DS-5
 or `scp` (or `pscp` on Windows).

To create a standalone package of files for decoding by DS-5 Debugger, for example to give to someone else, collect the files above,
together with `vmlinux`, and the kernel source tree.

Analyzing the collected trace in DS-5 (v5.21 onwards)
----------------------------------------------------

The files created by `tracedemo`, after copying to the host, can be loaded into DS-5 Debugger to analyze the collected trace as follows:

1. Launch Eclipse for DS-5.
2. From the **Window** menu, select **Perspective** -> **Open Perspective** -> **DS-5 Debug**.
3. From the **Run** menu, select **Debug Configurations...**.
4. In the **Debug Configurations** dialog, open the **DS-5 Debugger** node.
5. Create a new debug configuration and give it a name.
6. In the **Debugger** tab click the **Connect only** radio button.
7. In the **Connection** tab tree view, open the **Generic** platform, then select **SnapShot** -> **View Snapshot** -> **View Snapshot**.
8. In the Connection field below, enter the path to the top-level snapshot contents file `snapshot.ini`.
   You can use the **File...** button to navigate to the file.

   To load the ready-made example files, specify e.g.

   `.../DS-5 Workspace/CoreSight_access/example_captures/Snowball/snapshot.ini`.
9. To view the disassembly and trace augmented with symbols (e.g. function names), the `vmlinux` file for the kernel must be given.

   In the **Files** tab, select **Load symbols from file**, and use the **File System...** or **Workspace...** buttons to navigate to the `vmlinux` file.

10. In cases where the kernel modifies itself, you can force DS-5 Debugger to use program code from `kernel_dump.bin` rather than `vmlinux`.

   In the **Debugger** tab, tick **Execute debugger commands**, and add `set trust-ro-sections-for-opcodes off` to its field

11. Press **Debug**.

Ready-made example files captured from a session on a Snowball (ARMv7-A) target, an ARM TC2 (ARMv7-A) and a Juno (ARMv8-A) target are provided
in the `./example_captures/Snowball`, `./example_captures/TC2` and `./example_captures/Juno` directories that can be
used for test or demo purposes.  Ready-made debug config launch files `Generic-Snapshot-<platform>.launch` are
also provided for each of the above ready made captures.

Known issues and troubleshooting
--------------------------------

- If you see: `** csaccess: ERROR: can't open /dev/mem`, then try running `tracedemo` as either root or sudo:

      sudo ./tracedemo

- If you see:

      Unable to connect to snapshot.ini
      Unable to configure connection to system specified in configuration file
      Couldn't find size of 'kernel_dump.bin' - perhaps the file is missing or unreadable

  then `kernel_dump.bin` is missing or unreadable.  (Re-)create `kernel_dump.bin` as described earlier.

repository: ARM-software/CSAL

gha_language: C

gha_license_id: NOASSERTION

repo_name: ARM-software/CSAL


text:
### Drum voice synthesizer Firmware

Callisto Drum synthesizer, featuring 3 modes for kick, snare and hat sounds. With 3 waveforms each.

#### Parameters
* Pitch.
* Decay.
* Modulation Depth, bipolar, left envelope, right LFO.
* Modulation Rate, Envelope decay and LFO speed.
* DJ style filter, bipolar low-pass and high-pass.
* Overdrive.
* Instrument Select mode.
* Waveform Select mode.

#### Layout
![](https://github.com/ghztomash/callisto-module/blob/master/docs/callisto-drum.png)

repository: ghztomash/callisto-module

repo_name: ghztomash/callisto-module


text:
But you **can add your own Brands** if you have multiple Brands in your catalog.

This endpoint creates a new Brand.

### HTTP Request

`POST https://dashboard.shoprunback.com/api/v1/brands`

### Query Parameters

Parameter | Required | Description
--------- | ----------|------------
**name** | yes | Name of the brand, displayed to the customer on the return process
**reference** | yes | Unique reference of the brand (if you don't have any, use the name)

<aside class="success">
If you don't have more than one brand, you don't have to create another one, the default brand is enough.
</aside>

## List your brands

```ruby
HTTParty.get(
              "https://dashboard.shoprunback.com/api/v1/brands",
              headers: {
                'Content-Type' => 'application/json',
                'Authorization' => "Token token=#{your_token}"
              }
            )
```

```shell
curl -X "GET" "https://dashboard.shoprunback.com/api/v1/brands" \
     -H "Authorization: Token token=<your_token>" \
```

```php
<?php
// Load the library
require 'path/to/lib/shoprunback-php/init.php';

// Set your token
\Shoprunback\RestClient::getClient()->setToken('your_token');

// Define the environment you want to use (Production or Sandbox)
\Shoprunback\RestClient::getClient()->useProductionEnvironment();

// Get all your brands
$brands = \Shoprunback\Elements\Brand::all();
```

> The above command returns JSON structured like this:

```json
[
  {
    "id": "1f27f9d9-3b5c-4152-98b7-760f56967deb",
    "name": "default",
    "reference": "default",
    "default": true,
  },
  {
    "id": "1f27f9d9-3b5c-4152-98b7-760f56967dea",
    "name": "Apple",
    "reference": "apple",
    "default": false,
  },
  {
    "id": "1f27f9d9-3b5c-4152-98b7-760f56967dec",
    "name": "Samsung",
    "reference": "samsung",
    "default": false,
  }
]
```

This endpoint lists all your brands.

### HTTP Request

`GET https://dashboard.shoprunback.com/api/v1/brands`

repository: shoprunback/documentation

repo_name: shoprunback/documentation


text:
# Kubernetes and Docker on Mac and Windows

## Quick jump
- [Mac / Hyperkit](#mac--hyperkit)
- [Windows / Hyper-V](#windows--hyper-v)

## Supported scenarios
- Multi-node (or single-node) Kubernetes on CentOS/Ubuntu in Hyper-V/Hyperkit
- Docker on Desktop without Docker for Desktop

## Changelog
- v1.0.3 remove runc workaround also from mac; remove helm 2 support; always update kubectl and helm
- v1.0.2 preselect k8s version; remove runc workaround
- v1.0.1 repo cmd; selectable pkg versions; auto-untaint master if no workers
- v1.0.0 initial release

# Mac / Hyperkit
```bash

# tested on Hyperkit 0.20190802 on macOS 10.14.5 w/ APFS, guest images Centos 1907 and Ubuntu 18.04
# note: `sudo` is necessary for access to macOS Hypervisor and vmnet frameworks, and /etc/hosts config
# hint: disable sudo timeout by:
#      `echo "Defaults    timestamp_timeout=-1" | sudo tee /private/etc/sudoers.d/sudo-notimeout`

# download the script
cd workdir
curl https://raw.githubusercontent.com/youurayy/hyperctl/master/hyperctl.sh -O
chmod +x hyperctl.sh

# display short synopsis for the available commands
./hyperctl.sh
'
  Usage: ./hyperctl.sh command+

  Commands:

     (pre-requisites are marked with ->)

  -> install - install basic homebrew packages
      config - show script config vars
       print - print contents of relevant config files
  ->     net - create or update the vmnet config
  ->    dhcp - append to the dhcp registry
       reset - reset the vmnet and dhpc configs
  ->   hosts - append node names to etc/hosts
  ->   image - download the VM image
      master - create and launch master node
       nodeN - create and launch worker node (node1, node2, ...)
        info - display info about nodes
        init - initialize k8s and setup host kubectl
      reboot - soft-reboot the nodes
    shutdown - soft-shutdown the nodes
        stop - stop the VMs
       start - start the VMs
        kill - force-stop the VMs
      delete - delete the VM files
         iso - write cloud config data into a local yaml
    timesync - setup sleepwatcher time sync
      docker - setup local docker with the master node
       share - setup local fs sharing with docker on master
        helm - setup helm 3
        repo - install local docker repo in k8s
'

# performs `brew install hyperkit qemu kubernetes-cli`.
# (will not install the package if you already have the required binary in path; kubernetes-cli will be updated)
# (qemu is necessary for `qemu-img`)
# you may perform these manually / selectively instead.
./hyperctl.sh install

# display configured variables (edit the script to change them)
# note: to quickly change distro, do `echo bionic >> .distro`
./hyperctl.sh config
'
   VERSION: v1.0.0
    CONFIG: centos
    DISTRO: centos
   WORKDIR: ./tmp
 GUESTUSER: user
   SSHPATH: /Users/user/.ssh/id_rsa.pub
  IMAGEURL: https://cloud.centos.org/centos/7/images/CentOS-7-x86_64-GenericCloud-1907.raw.tar.gz
  DISKFILE: CentOS-7-x86_64-GenericCloud-1907.raw
      CIDR: <IP_ADDRESS>/24
      CPUS: 4
       RAM: 4GB
       HDD: 40G
       CNI: flannel
    CNINET: <IP_ADDRESS>/16
   CNIYAML: https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
 DOCKERCLI: https://download.docker.com/mac/static/stable/x86_64/docker-19.03.1.tgz
'

# print external configs that this script can change
./hyperctl.sh print

# cleans or creates /Library/Preferences/SystemConfiguration/com.apple.vmnet.plist
# and sets the CIDR configured in the script.
# if other apps already use the vmnet framework, then you don't want to change it, in
# which case don't run this command, but instead set the CIDR inside this script
# to the value from the vmnet.plist (as shown by the 'print' command).
./hyperctl.sh net

# appends IPs and MACs from the NODES config to the /var/db/dhcpd_leases.
# this is necessary to have predictable IPs.
# (MACs are generated from UUIDs by the vmnet framework.)
./hyperctl.sh dhcp

# if initialization through 'net' and 'dhcp' commands is unsuccessful, i.e. the
# vmnet framework assigns our VMs wrong IP addresses, this commands deletes
# the above two files, after which you can manually reboot and try again.
./hyperctl.sh reset

# appends IP/hostname pairs from the NODES config to the /etc/hosts.
# (the same hosts entries will also be installed into every node)
./hyperctl.sh hosts

# download, prepare and cache the VM image templates
./hyperctl.sh image

# create/launch the nodes
./hyperctl.sh master
./hyperctl.sh node1
./hyperctl.sh nodeN...
# ---- or -----
./hyperctl.sh master node1 node2 nodeN...

# ssh to the nodes if necessary (e.g. for manual k8s init)
# by default, your `.ssh/id_rsa.pub` key was copied into the VMs' ~/.ssh/authorized_keys
# uses your host username (which is the default), e.g.:
ssh master
ssh node1
ssh node2
...

# performs automated k8s init (will wait for VMs to finish init first)
./hyperctl.sh init

# after init, you can do e.g.:
hyperctl get pods --all-namespaces
'
NAMESPACE     NAME                             READY   STATUS    RESTARTS   AGE
kube-system   coredns-5c98db65d4-b92p9         1/1     Running   1          5m31s
kube-system   coredns-5c98db65d4-dvxvr         1/1     Running   1          5m31s
kube-system   etcd-master                      1/1     Running   1          4m36s
kube-system   kube-apiserver-master            1/1     Running   1          4m47s
kube-system   kube-controller-manager-master   1/1     Running   1          4m46s
kube-system   kube-flannel-ds-amd64-6kj9p      1/1     Running   1          5m32s
kube-system   kube-flannel-ds-amd64-r87qw      1/1     Running   1          5m7s
kube-system   kube-flannel-ds-amd64-wdmxs      1/1     Running   1          4m43s
kube-system   kube-proxy-2p2db                 1/1     Running   1          5m32s
kube-system   kube-proxy-fg8k2                 1/1     Running   1          5m7s
kube-system   kube-proxy-rtjqv                 1/1     Running   1          4m43s
kube-system   kube-scheduler-master            1/1     Running   1          4m38s
'

# reboot the nodes
./hyperctl.sh reboot

# show info about existing VMs (size, run state)
./hyperctl.sh info
'
NAME    PID    %CPU  %MEM  RSS   STARTED  TIME     DISK  SPARSE  STATUS
master  36399  0.4   2.1   341M  3:51AM   0:26.30  40G   3.1G    RUNNING
node1   36418  0.3   2.1   341M  3:51AM   0:25.59  40G   3.1G    RUNNING
node2   37799  0.4   2.0   333M  3:56AM   0:16.78  40G   3.1G    RUNNING
'

# shutdown all nodes thru ssh
./hyperctl.sh shutdown

# start all nodes
./hyperctl.sh start

# stop all nodes
./hyperctl.sh stop

# force-stop all nodes
./hyperctl.sh kill

# delete all nodes' data (will not delete image templates)
./hyperctl.sh delete

# kill only a particular node
sudo kill -TERM 36418

# delete only a particular node
rm -rf ./tmp/node1/

# remove everything
sudo killall -9 hyperkit
rm -rf ./tmp

# exports the cloud-init yaml into ./$distro.yaml for review
./hyperctl.sh iso

# installs and configures sleepwatcher to call this script to update the
# VMs clocks after your Mac wakes up from sleep
./hyperctl.sh timesync

# installs local docker cli (docker.exe) and helps you configure it to connect
# to the docker running on the master node
./hyperctl.sh docker

# walks you through a file sharing setup between local machine and the master node,
# so that you can work with docker volumes.
# this is semi-interactive so that your password is never stored anywhere insecurely.
# this also means that you have to repeat this if you restart the master node.
# alternatively, you can add the mount into master's fstab with a password= option.
# note: the SMB file sharing does not support filesystem inotify events.
./hyperctl.sh share

```

# Windows / Hyper-V
```powershell

# tested with PowerShell 5.1 on Windows 10 Pro 1903, guest images Centos 1907 and Ubuntu 18.04
# note: admin access is necessary for access to Windows Hyper-V framework and etc/hosts config
# note: you may need to recurisvely remove public access (at least) from your ~/.ssh dir,
#       (suggested: whole homedir) othwerwise ssh will refuse to work.

# open PowerShell (Admin) prompt
cd $HOME\your-workdir

# download the script
curl https://raw.githubusercontent.com/youurayy/hyperctl/master/hyperctl.ps1 -outfile hyperctl.ps1
# enable script run permission
set-executionpolicy remotesigned

# display short synopsis for the available commands
.\hyperctl.ps1
'
  Usage: .\hyperctl.ps1 command+

  Commands:

     (pre-requisites are marked with ->)

  -> install - install basic chocolatey packages
      config - show script config vars
       print - print etc/hosts, network interfaces and mac addresses
  ->     net - install private or public host network
  ->   hosts - append private network node names to etc/hosts
  ->   image - download the VM image
      master - create and launch master node
       nodeN - create and launch worker node (node1, node2, ...)
        info - display info about nodes
        init - initialize k8s and setup host kubectl
      reboot - soft-reboot the nodes
    shutdown - soft-shutdown the nodes
        save - snapshot the VMs
     restore - restore VMs from latest snapshots
        stop - stop the VMs
       start - start the VMs
      delete - stop VMs and delete the VM files
      delnet - delete the network
         iso - write cloud config data into a local yaml
      docker - setup local docker with the master node
       share - setup local fs sharing with docker on master
        helm - setup helm 3
        repo - install local docker repo in k8s
'

# performs `choco install 7zip.commandline qemu-img kubernetes-cli`
# (will not install the package if you already have the required binary in path; kubernetes-cli will be updated)
# you may instead perform these manually / selectively instead.
# note: 7zip is needed to extract .xz archives
# note: qemu-img is needed convert images to vhdx
.\hyperctl.ps1 install

# display configured variables (edit the script to change them)
# note: to quickly change distro, do e.g. `echo centos >> .distro`
.\hyperctl.ps1 config
'
   version: v1.0.0
    config: bionic
    distro: ubuntu
   workdir: .\tmp
 guestuser: user
   sshpath: C:\Users\user\.ssh\id_rsa.pub
  imageurl: https://cloud-images.ubuntu.com/releases/server/18.04/release/ubuntu-18.04-server-cloudimg-amd64.img
  vhdxtmpl: .\tmp\ubuntu-18.04-server-cloudimg-amd64.vhdx
      cidr: <IP_ADDRESS>/24
    switch: switch
   nettype: private
    natnet: natnet
      cpus: 4
       ram: 4GB
       hdd: 40GB
       cni: flannel
    cninet: <IP_ADDRESS>/16
   cniyaml: https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
 dockercli: https://github.com/StefanScherer/docker-cli-builder/releases/download/19.03.1/docker.exe
'

# print relevant configuration - etc/hosts, mac addresses, network interfaces
.\hyperctl.ps1 print

# create a private network for the VMs, as set by the `cidr` variable
.\hyperctl.ps1 net

# appends IP/hostname pairs to the /etc/hosts.
# (the same hosts entries will also be installed into every node)
.\hyperctl.ps1 hosts

# download, prepare and cache the VM image templates
.\hyperctl.ps1 image

# create/launch the nodes
.\hyperctl.ps1 master
.\hyperctl.ps1 node1
.\hyperctl.ps1 nodeN...
# ---- or -----
.\hyperctl.ps1 master node1 node2 nodeN...

# ssh to the nodes if necessary (e.g. for manual k8s init)
# by default, your `.ssh/id_rsa.pub` key was copied into the VMs' ~/.ssh/authorized_keys
# uses your host username (which is the default), e.g.:
ssh master
ssh node1
ssh node2
...

# perform automated k8s init (will wait for VMs to finish init first)
# (this will checkpoint the nodes just before `kubeadm init`)
.\hyperctl.ps1 init

# after init, you can do e.g.:
hyperctl get pods --all-namespaces
'
NAMESPACE     NAME                             READY   STATUS    RESTARTS   AGE
kube-system   coredns-5c98db65d4-b92p9         1/1     Running   1          5m31s
kube-system   coredns-5c98db65d4-dvxvr         1/1     Running   1          5m31s
kube-system   etcd-master                      1/1     Running   1          4m36s
kube-system   kube-apiserver-master            1/1     Running   1          4m47s
kube-system   kube-controller-manager-master   1/1     Running   1          4m46s
kube-system   kube-flannel-ds-amd64-6kj9p      1/1     Running   1          5m32s
kube-system   kube-flannel-ds-amd64-r87qw      1/1     Running   1          5m7s
kube-system   kube-flannel-ds-amd64-wdmxs      1/1     Running   1          4m43s
kube-system   kube-proxy-2p2db                 1/1     Running   1          5m32s
kube-system   kube-proxy-fg8k2                 1/1     Running   1          5m7s
kube-system   kube-proxy-rtjqv                 1/1     Running   1          4m43s
kube-system   kube-scheduler-master            1/1     Running   1          4m38s
'

# reboot the nodes
.\hyperctl.ps1 reboot

# show info about existing VMs (size, run state)
.\hyperctl.ps1 info
'
Name   State   CPUUsage(%) MemoryAssigned(M) Uptime           Status             Version
----   -----   ----------- ----------------- ------           ------             -------
master Running 3           5908              00:02:25.5770000 Operating normally 9.0
node1  Running 8           4096              00:02:22.7680000 Operating normally 9.0
node2  Running 2           4096              00:02:20.1000000 Operating normally 9.0
'

# checkpoint the VMs
.\hyperctl.ps1 save

# restore the VMs from the lastest snapshot
.\hyperctl.ps1 restore

# shutdown all nodes thru ssh
.\hyperctl.ps1 shutdown

# start all nodes
.\hyperctl.ps1 start

# stop all nodes thru hyper-v
.\hyperctl.ps1 stop

# delete all nodes' data (will not delete image templates)
.\hyperctl.ps1 delete

# delete the network
.\hyperctl.ps1 delnet

# installs local docker cli (docker.exe) and helps you configure it to connect
# to the docker running on the master node
.\hyperctl.ps1 docker

# walks you through a file sharing setup between local machine and the master node,
# so that you can work with docker volumes.
# this is semi-interactive so that your password is never stored anywhere insecurely.
# this also means that you have to repeat this if you restart the master node.
# alternatively, you can add the mount into master's fstab with a password= option.
.\hyperctl.ps1 share

# NOTE if Hyper-V stops working after a Windows update, do:
# Windows Security -> App & Browser control -> Exploit protection settings -> Program settings ->
# C:\WINDOWS\System32\vmcompute.exe -> Edit-> Code flow guard (CFG) ->
# uncheck Override system settings -> # net stop vmcompute -> net start vmcompute

# NOTE if Hyper-V VMs stop responding after updating to Windows 10 1903,
# perform `Restart-Service 'HV Host Service'` in an admin PowerShell.

```

#### License: https://www.apache.org/licenses/LICENSE-2.0

repository: hi-eu/hyperctl

repo_name: hi-eu/hyperctl


text:
# WP Acceptance

> WP Acceptance is a toolkit that empowers developers and CI pipelines to test codebases using version controlled acceptance tests and sharable environments.

[![Support Level](https://img.shields.io/badge/support-beta-blueviolet.svg)](#support-level) [![Release Version](https://img.shields.io/github/v/tag/10up/wpacceptance?label=version)](https://github.com/10up/wpacceptance/releases) [![Documentation Status](https://readthedocs.org/projects/wpacceptance/badge/?version=latest)](https://wpacceptance.readthedocs.io/en/latest/?badge=latest) [![MIT License](https://img.shields.io/github/license/10up/wpacceptance.svg)](https://github.com/10up/wpacceptance/blob/master/LICENSE.md)

## Requirements

* PHP 7.2+
* [mysqli PHP extension](https://www.php.net/manual/en/book.mysqli.php)
* Docker ([WP Local Docker](https://github.com/10up/wp-local-docker) is highly recommended as the local development environment but not required.)
* Node >= 8 (WP Acceptance uses [Puppeteer](https://pptr.dev/) behind the scenes.)

*Note:* WP Acceptance should be run on your HOST machine and not within Docker.

## How It Works

There are many acceptance tests frameworks out there. They all have one major flaw - everyone executing the acceptance tests must be running the exact same code on the exact same database and environment to guarantee the same results. Ensuring a team of developers (and a CI pipeline) are all using the same database in the same environment has been nearly impossible until now. WP Acceptance is unique in that it allows you to run your acceptance tests against a codebase in defined and shareable environments.  Read more in our [announcement blog post](https://10up.com/blog/2019/introducing-wp-acceptance/).

## Install

Installation instructions are on the [docs site](https://wpacceptance.readthedocs.io/en/latest/#installation).

## Usage

Learn how to use WP Acceptance on the [docs site](https://wpacceptance.readthedocs.io/en/latest/cookbook/).

## Support Level
**Beta:** This project is quite new and we're not sure what our ongoing support level for this will be.  Bug reports, feature requests, questions, and pull requests are welcome.  If you like this project please let us know, but be cautious using this in a Production environment!

## Like what you see?

repository: next-press/wpacceptance

branch_name: refs/heads/develop

gha_language: PHP

repo_name: next-press/wpacceptance


text:
---
layout: default
---

# 1994-12-02 - Re: Brands excluded from digicash beta

## Header Data

From<EMAIL_ADDRESS>(Jim McCoy)

To<EMAIL_ADDRESS>(Wolfgang Roeckelein)

Message Hash: f05f0635312f2c38f861911a386851bc6fb18beccf3da52d2cb0e533d6206267

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-12-02 13:11:54 UTC

Raw Date: Fri, 2 Dec 94 05:11:54 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Jim McCoy)
Date: Fri, 2 Dec 94 05:11:54 PST
To<EMAIL_ADDRESS>(Wolfgang Roeckelein)
Subject: Re: Brands excluded from digicash beta
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Wolfgang Roeckelein<EMAIL_ADDRESS>writes:
>
> Does anybody know how the chaum patents (I think they claimed somewhere
> that they had applied for some) affect Brands system?

Chaum has several patents relating to digital cash, the core one being a
patent on the blind signature methods commonly in use.  When I last heard
an update on the Chaum/Brand saga it was that Brand believed his system
avoided Chaum's patents while Chaum "had not yet been convinced that this
was so, but it was a possibility."

jim

{% endraw %}
```

## Thread

+ Return to [December 1994](/archive/1994/12)

+ Return to<EMAIL_ADDRESS>(Jim McCoy)](/authors/mccoy_at_io_com_jim_mccoy_)"
+ Return to "[Wolfgang Roeckelein <wolfgang@wi.WHU-Koblenz.de>](/authors/wolfgang_roeckelein_wolfgang_at_wi_whukoblenz_de_)"

+ 1994-12-02 (Fri, 2 Dec 94 02:05:33 PST) - [Re: Brands excluded from digicash beta](/archive/1994/12/6ef2807d632602bf54161f01b088ee48fa807af08fb210219fd12232b3fda39c) - _Wolfgang Roeckelein<EMAIL_ADDRESS>  + 1994-12-02 (Fri, 2 Dec 94 05:11:54 PST) - Re: Brands excluded from digicash beta -<EMAIL_ADDRESS>(Jim McCoy)_


text:
## npm-pkginfo

Lightweight version of [npm-registry-client.get()](https://github.com/isaacs/npm-registry-client#clientgeturl-timeout-nofollow-staleok-cb) that supports custom cache stores.

### Motivation

I wrote this module because `npm-registry-client` was missing some features and had others which I didn't need:
- it didn't allow custom cache stores
- event though it could load the package info from the cache it did a background update after that

### Usage

```js
var Client = require('npm-pkginfo'),
    client;

// note: the memory store is only for testing / examples
// in production you should either use the fsStore (see commented lines below)
// or another custom store
client = new Client({
  cacheStore: new Client.stores.memory()
});

// Uncomment below to use the fs cache store
// client = new Client({
//   cacheDir: __dirname + '/cache'
// });

// fetch the request module from NPM
client.get('request', function(err, info) {
  if (err) { throw err; }

  console.log('Request versions: ', Object.keys(info.versions).join(', '));
  console.log('---');

  // this time it will load the info from the cache, without making any requests to NPM
  client.get('request', { staleOk: true }, function(err, info) {
    if (err) { throw err; }

    console.log('Request versions: ', Object.keys(info.versions).join(', '));
  });
});
```

For advanced usage, read the tests.

### LICENSE

MIT

repository: alessioalex/npm-pkginfo

repo_name: alessioalex/npm-pkginfo


text:
# flutter_redux_hooks

[![pub package](https://img.shields.io/pub/v/flutter_redux_hooks.svg)](https://pub.dartlang.org/packages/flutter_redux_hooks)
[![Build Status](https://travis-ci.com/mrnkr/flutter_redux_hooks.svg?branch=master)](https://travis-ci.com/mrnkr/flutter_redux_hooks)
[![codecov](https://codecov.io/gh/mrnkr/flutter_redux_hooks/branch/master/graph/badge.svg)](https://codecov.io/gh/mrnkr/flutter_redux_hooks)

A set of utilities that allow you to easily consume a [Redux](https://pub.dartlang.org/packages/redux) Store to build Flutter Widgets.

This package is built to work with [Redux.dart](https://pub.dartlang.org/packages/redux) 3.0.0+.

This library is based on [flutter_redux](https://github.com/brianegan/flutter_redux), it actually started as a fork of that project. The implementation of `StoreProvider` available here is the same you will find in that lib, I removed the rest of the widgets offered by it and replaced them with my hooks. Clearly, I aimed to replicate the behavior of the hooks you'll find in [react-redux](https://github.com/reduxjs/react-redux), if you think I succeeded let me know by leaving a star in the repo!

## Redux Widgets

* `StoreProvider` - The base Widget. It will pass the given Redux Store to all descendants that request it.

## Redux hooks

* `useStore` - Will return a reference to the store you provided via `StoreProvider`.
* `useDispatch` - Will return a reference to the dispatch function for the store you provided via `StoreProvider`.
* `useSelector` - Will return the result of applying a selector function to the state. To make these selectors I recommend either using `reselect` or `redux_toolkit` (`redux_toolkit` exports `reselect`).

### Companion Libraries

* [flipperkit_redux_middleware](https://pub.dartlang.org/packages/flipperkit_redux_middleware) - Redux Inspector (use [Flutter Debugger](https://github.com/blankapp/flutter-debugger)) for Flutter Redux apps
* [flutter_redux_dev_tools](https://pub.dartlang.org/packages/flutter_redux_dev_tools) - Time Travel Dev Tools for Flutter Redux apps
* [redux_persist](https://github.com/Cretezy/redux_persist) - Persist Redux State
* [flutter_redux_navigation](https://github.com/flutterings/flutter_redux_navigation) - Use redux events for navigation
* [redux_toolkit](https://github.com/mrnkr/redux_toolkit) - Dart port of the official, opinionated, batteries-included toolset for efficient Redux development.

## Usage

Let's demo the basic usage with the all-time favorite: A counter example!

```dart
import 'package:flutter/material.dart';
import 'package:flutter_hooks/flutter_hooks.dart' show HookWidget;
import 'package:flutter_redux_hooks/flutter_redux_hooks.dart';
import 'package:redux/redux.dart';

enum Actions { Increment }

int counterReducer(int state, dynamic action) {
  if (action == Actions.Increment) {
    return state + 1;
  }

  return state;
}

void main() {
  final store = Store<int>(counterReducer, initialState: 0);

  runApp(
    StoreProvider<int>(
      store: store,
      child: FlutterReduxApp(
        title: 'Flutter Redux Demo',
      ),
    ),
  );
}

class FlutterReduxApp extends HookWidget {
  final String title;

  FlutterReduxApp({Key key, this.title}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    final dispatch = useDispatch<int>();
    final count = useSelector<int, String>((state) => state.toString());

    return MaterialApp(
      theme: ThemeData.dark(),
      title: title,
      home: Scaffold(
        appBar: AppBar(
          title: Text(title),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Text(
                'You have pushed the button this many times:',
              ),
              Text(
                count,
                style: TextStyle(color: Colors.white, fontSize: 36),
              ),
            ],
          ),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () => dispatch(Actions.Increment),
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}
```

## Purpose

One question that [reasonable people might ask](https://www.reddit.com/r/FlutterDev/comments/6vscdy/a_set_of_utilities_that_allow_you_to_easily/dm3ll7d/): Why do you need all of this if `StatefulWidget` exists?

My advice is the same as the original Redux.JS author: If you've got a simple app, use the simplest thing possible. In Flutter, `StatefulWidget` is perfect for a simple counter app.

However, say you have more complex app, such as an E-commerce app with a Shopping Cart. The Shopping Cart should appear on multiple screens in your app and should be updated by many different types of Widgets on those different screens (An "Add Item to Cart" Widget on all your Product Screens, "Remove Item from Cart" Widget on the Shopping Cart Screen, "Change quantity" Widgets, etc).

Additionally, you definitely want to test this logic, as it's the core business logic to your app!

Now, in this case, you could create a Testable `ShoppingCart` class as a Singleton or Create a Root `StatefulWidget` that passes the `ShoppingCart` *Down Down Down* through your widget hierarchy to the "add to cart" or "remove from cart" Widgets .

Singletons can be problematic for testing, and Flutter doesn't have a great Dependency Injection library (such as Dagger2) just yet, so I'd prefer to avoid those.

Yet passing the ShoppingCart all over the place can get messy. It also means it's way harder to move that "Add to Item" button to a new location, b/c you'd need up update the Widgets throughout your app that passes the state down.

Furthermore, you'd need a way to Observe when the `ShoppingCart` Changes so you could rebuild your Widgets when it does (from an "Add" button to an "Added" button, as an example).

One way to handle it would be to simply `setState` every time the `ShoppingCart` changes in your Root Widget, but then your whole app below the RootWidget would be required to rebuild as well! Flutter is fast, but we should be smart about what we ask Flutter to rebuild!

Therefore, `redux` & `redux_flutter` was born for more complex stories like this one. It gives you a set of tools that allow your Widgets to `dispatch` actions in a naive way, then write the business logic in another place that will take those actions and update the `ShoppingCart` in a safe, testable way.

Even more, once the `ShoppingCart` has been updated in the `Store`, the `Store` will emit an `onChange` event. This lets you listen to `Store` updates and rebuild your UI in the right places when it changes!

Similar patterns in Android are the MVP Pattern, or using Rx Observables to manage a View's state.

`flutter_redux` simply handles passing your `Store` down to all of your descendant `StoreConnector` Widgets. If your State emits a change event, only the `StoreConnector` Widgets and their descendants will be automatically rebuilt with the latest state of the `Store`!

This allows you to focus on what your app should look like and how it should work without thinking about all the glue code to hook everything together!

### Contributors

* [Alvaro Nicoli](https://github.com/mrnkr)
* [Brian Egan](https://github.com/brianegan)
* [Chris Bird](https://github.com/chrisabird)


text:
# acme-tic-tac-toe

Play Tic-tac-toe in Acme text editor.

## Show, don't tell

![Tic-tac-toe for Acme](./ttt.gif)

## Inspired by
- [Tic-tac-toe in Emacs](https://www.youtube.com/watch?v=gk39mp8Vy4M)
- [adict -- dictionary for Acme](https://www.youtube.com/watch?v=dP1xVpMPn8M&t=14m22s)

## Lear more about Acme

[github.com/evbogdanov/acme](https://github.com/evbogdanov/acme)

repository: evbogdanov/acme-tic-tac-toe

repo_name: evbogdanov/acme-tic-tac-toe


text:
hx mirador
===============

lti provider of mirador instances.

quick start
============

hxmirador (specifically, hxlti) requires a redis instance running, and by default it will look for
`redis://localhost:6379/0`. Make sure there is a redis instance running and
configured in hxmirador/settings/prod.py

To stand a local hxmirador lti provider instance, follow these quick steps:

    # clone this repo
    $> git clone https://github.com/nmaekawa/hxmirador.git
    $> cd hxmirador

    # create and activate a virtualenv
    $> cd hxmirador
    $hxmirador> virtualenv -p python3 venv
    $hxmirador> source venv/bin/activate
    $(venv) hxmirador>

    # install pip requirements
    $(venv) hxmirador> pip install -r requirements/dev.txt

    # install hxmirador
    $(venv) hxmirador> pip install -e .

    # edit the dotenv sample.env file as you wish
    $(venv) hxmirador> cp hxmirador/settings/sample.env ./sample.env
    $(venv) hxmirador> vi sample.env
    ...

    # run migrations
    $(venv) hxmirador> (HXMIRADOR_DOTENV_PATH=sample.env manage.py migrate)

    # create django admin superuser
    $(venv) hxmirador> (HXMIRADOR_DOTENV_PATH=sample.env manage.py createsuperuser)
    ...

    # run hxmirador
    $(venv) hxmirador> (HXMIRADOR_DOTENV_PATH=sample.env manage.py runserver)

If all goes well, you should be able to access django admin ui at:

    http://localhost:8000/admin

using the superuser you just created, and then create a `consumer` key.

hxmirador is part of [hximg][https://github.com/nmaekawa/hximg-provision] (hx
backend for mirador), please refer to its readme for details in how to stand a
vagrant instance.

# about lti consumer config for hxmirador lti provider

You can configure your lti consumer with the consumer key created in the
previous step. Other lti configs are:

    launch_url: http://localhost:8000/mirador/launch

    custom_manifests: ["http://manifests.vm/manifests/sample:m123"]

Keep in mind that the lti consumer has to also be local!

# about hxmirador configuration

hxmirador has hxlti as dependency to implement the lti provider and hxlti needs
some configs in the env (see dotenv `hxmirador/settings/sample.env`):

    # dummy consumer key for oauthlib
    HXLTI_DUMMY_CONSUMER_KEY
    ex: HXLTI_DUMMY_CONSUMER_KEY='123456789012345678901234567890'

    # url for redis instance
    HXLTI_REDIS_URL
    ex: HXLTI_REDIS_URL='redis://localhost:6379/0'

for details on hxlti django app, see
[hxlti-djapp][https://github.com/nmaekawa/hxlti-djapp.git]

---eop

repository: nmaekawa/hxmirador

repo_name: nmaekawa/hxmirador


text:
[//]: #@corifeus-header

[![NPM](https://nodei.co/npm/p3x-redis-ui.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/p3x-redis-ui/)

[![Donate for Corifeus / P3X](https://img.shields.io/badge/Donate-Corifeus-003087.svg)](https://paypal.me/patrikx3) [![Contact Corifeus / P3X](https://img.shields.io/badge/Contact-P3X-ff9900.svg)](https://www.patrikx3.com/en/front/contact) [![Corifeus @ Facebook](https://img.shields.io/badge/Facebook-Corifeus-3b5998.svg)](https://www.facebook.com/corifeus.software)  [![Build Status](https://github.com/patrikx3/redis-ui/workflows/build/badge.svg)](https://github.com/patrikx3/redis-ui/actions?query=workflow%3Abuild)
[![Uptime Robot ratio (30 days)](https://img.shields.io/uptimerobot/ratio/m780749701-41bcade28c1ea8154eda7cca.svg)](https://stats.uptimerobot.com/9ggnzcWrw)

# 📡 P3X Redis UI is a very functional handy database GUI and works in your pocket on the responsive web or as a desktop app v2023.10.246

**Bugs are evident™ - MATRIX**

### NodeJS LTS is supported

### Built on NodeJs version

```txt
v20.5.0
```

# Description

[//]: #@corifeus-header:end

`p3x-redis-ui` is a new Redis GUI which can serve as a backend server or as a desktop application.

Some of the features are coming below.

The best use case for this Redis GUI, if you manage tons of JSON, as it includes JSONEditor and ACE. Check out the different options in the edit json button dialog. :)

<!--
👷 **The first full complete version was created in 20 days in September of 2018.**
-->

<!--
## Donated-Ware features

**Until further notice, all donated-ware features are enabled for free. Please, test out your use case, how the JSON editor is helping you. Let us know!**

The `p3x-redis-ui+` version has additional features.
The donation is $1/month. Please contact at [alabard<EMAIL_ADDRESS>and can donate @ https://paypal.me/patrikx3

The features that are only working in the donated-ware version:
* JSON editor
* Cluster
* AWS ElastiCache
* Gcloud memorystore
* Azure Redis

To check if your license is valid @
https://server.patrikx3.com/api/patrikx3/redis-ui/status/your-license-key

#### New features
Users, that donated, have a big chance that requests for new features will be implemented.

##### Possible new features
* SSH tunnel
* Upload binary data
* Collapse/expand recursively on individual leafs

#### Plus function problems
Given, I do not have a full fledged server and to maintain the servers it costs money, it is possible, sometimes the server goes down. It is rare, but it will be back up probably in 5-10 minutes. If there is a problem that is longer, please contact me.

### Contributors license
Contributors get plus donate license for free for a year.
Contributors, that created features that are working only in the donate-ware version get a license for life.

-->

## Warning
It is not recommend to generate the configuration `JSON` via a text editor. The perfect solution is to generate the configuration in the GUI, then apply for example in Kubernetes.

## The online current version
https://p3x.redis.patrikx3.com  <!-- - this is the plus version -->

This Redis database every day in the morning European time CET restores some data, so you may do whatever you want to do.

Besides, you could experience the test app to exit for 1 second, because it could auto update itself. It auto updates itself when the code from Git changes.

Third, it is a snapshot, it is possible, that the features are different from GitHub or NPM as the releases are usually monthly or as they happen.

### Screenshots
[Screenshots readme](artifacts/readme/screenshots.md)

## Releases

### Snap

<!--
The main source installer is the `AppImage`, so, the themes are not implemented (the main menus). If you want the themes to be implemented (dark vs light), I suggest using the `AppImage` as it supports the themes natively. Besides, the auto self update function is not implemented in `Snap`, only in `AppImage` version.
-->

[![LINK](https://snapcraft.io/static/images/badges/en/snap-store-black.svg)](https://snapcraft.io/p3x-redis-ui#cory-non-external)

### AppImage, dep, rpm

https://github.com/patrikx3/redis-ui/releases

AppImage, dep and rpm auto update itself.

#### To integrate into the menu using AppImage
Execute:
```bash
sudo add-apt-repository ppa:appimagelauncher-team/stable
sudo apt-get update
sudo apt-get install appimagelauncher
```

#### After downloading the ```AppImage```, make it an executable.
```bash
mkdir -p $HOME/opt
mv ~/Downloads/p3x-redis-ui-a.b.c-x86_64.AppImage $HOME/opt/
chmod +x $HOME/opt/p3x-redis-ui-a.b.c-x86_64.AppImage
# Then you can run it
$HOME/opt/p3x-redis-ui-a.b.c-x86_64.AppImage &
```

<!--
It then actually integrates itself into the menus and it will auto update itself.
-->

### On ElectronJs
The app can be found on [ElectronJs Apps](https://electronjs.org/apps) and search for `P3X`, you will find it.

### CLI

Start up with a server or via a browser and NodeJs/NPM.

[Start up with a server readme](artifacts/readme/start-up-server.md)

[Some description about the config file readme](p3xrs.json)

### Docker

https://hub.docker.com/r/patrikx3/p3x-redis-ui

#### Compose
https://github.com/patrikx3/redis-ui/blob/master/docker-compose.yml

```bash
wget https://raw.githubusercontent.com/patrikx3/redis-ui/master/docker-compose.yml
# You might want to tune the settings folder in the docker-compose.yml.
# the /home/user/p3x-redis-ui-settings settings folder in yml should be set by yourself.
docker-compose up
```

#### Bare

```bash
# you can tune the settings folder
# in the -v first part is where you can set your own folder
mkdir -p ./p3x-redis-ui-settings
docker run -v $PWD/p3x-redis-ui-settings:/settings -h docker-p3x-redis-ui -p 7843:7843 -t -i patrikx3/p3x-redis-ui
```

The GUI will be @ http://localhost:7843

### Kubernetes

A complete example of deployment `p3x-redis-ui` in kubernetes using raw manifests
https://github.com/patrikx3/redis-ui/blob/master/k8s/manifests

```bash
kubectl apply -f namespace.yaml
# Do not forget to edit redis host and password configuration
kubectl apply -f configmap.yaml
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml
```

Helm chart `p3x-redis-ui` deployment in kubernetes
https://github.com/patrikx3/redis-ui/blob/master/k8s/chart

```bash
helm template -f values.yaml release --namespace namespace . > generated.yaml
kubectl apply -f generated.yaml
```

## Features

* The console history is kept indefinite in the local storage
* Redis 6 with TLS is enabled with this information:
  * https://spin.atomicobject.com/2021/08/05/configuring-redis-tls/
* You can override the server port via an environment variable `P3XRS_PORT`
* In the connections, you can enable read only mode, which means, the user will not be able to modify via gui and the console (only pub/sub monitor and select database is allowed) is disabled.
* In a sub-directory, you can use Nginx/Ingress to rewrite your paths.
  * https://github.com/patrikx3/redis-ui/issues/43
* To show the menu in the desktop version, click ALT
* There is a new feature in the settings/tree setting, which limits the received keys, the minimum is 100, the maximum is 100k, so there is no more crash, because of that
* Since `v2020.4.189`, the tree can handle bigger key count, as of now, we are using deferred rendering for the tree - only rendering what is in the viewport, so it should be much faster versus rendering everything at once
* Please, check out your Redis use case, if this program can cover your requirements
* Does not handle binary data
* **Does not work with sentinel**, but it will be developed at some point of time
* **Has cluster support**
  * Thanks so much for the awesome contribution by [@idetoile](https://github.com/idetoile) (now -> [@devthejo](https://github.com/devthejo)) of the cluster function.
* Able to monitor all channel messages on the console by using a checkbox.
* Works with multiple languages
* Works as a backend
* Works as a desktop via Electron
  * Linux
  * Windows
* Starts with no settings without config, or setup your own config
* Able to create, test, save, delete multiple connections or a readonly connections setup, for shared usage*
* Online you are able to choose the tree separator, for example :, /, -, space etc... or even empty separator
* It is based on Redis-Commander and phpRedisAdmin
* You can select the database via console or the drop down.
   * The database select drop down shows if the checked database is empty or filled, so you can always know which is filled
* Save button to save the db
* Full statistics pages, can be useful
* This is just a New Kind on the Block in the Redis world, so, of course, there are advantages and disadvantages in the other Redis GUIs
* Dark - Dracula / light themes
* Search
  * Client side mode searching in keys - small key set
  * Server side mode searching in keys - large key set
  * Search mode
    * the search keys starts with a string key
    * the search keys includes a string in the key
* The app is responsive, it works on a phone/tablet as well
* There is a key sorting function, which has a penalty, because it sorts with natural-compare, which means it is more human display, then just raw characters, but up to 100k the keys is still ok.
* For big key set to be usable paging should be a maximum 1000 keys / page, though for 250 is the sweetest spot

# Change log
[The change log readme](change-log.md)

# Contributors
[The contributors readme](contributors.md)

# Development

For file names do not use camelCase, but use kebab-case. Folder should be named as kebab-case as well. As you can see, all code filenames are using it like that, please do not change that.
Please apply the `.editorconfig` settings in your IDE.

It creates a package that allows you to compose `p3x-redis-ui-server` and `p3x-redis-ui-material` into one:

[Server on GitHub](https://github.com/patrikx3/redis-ui-server)
[Client on GitHub](https://github.com/patrikx3/redis-ui-material)

If you develop on this app, you are required to test, that all JS you code write is working with Electron (as the embedded Electron NodeJs version is usually below the real NodeJs). Once the server and client is running as above, you clone this repo and test like this:
```bash
# terminal 1
git clone https://github.com/patrikx3/redis-ui-material.git
cd redis-ui-material
npm install
npm run dev

# terminal 2
git clone https://github.com/patrikx3/redis-ui-server.git
cd redis-ui-server
npm install
npm run dev

# if you are not working on Electron, at this point you can fire the browser
# @ http://localhost:8080/

# terminal 3
git clone https://github.com/patrikx3/redis-ui.git
cd redis-ui
npm install
./scripts/start-local.sh
# or
.\scripts\start-local.cmd
```

### Development of the translations

By default, only English is created, but given all strings are from a `JS` file, it is very quick to spawn another language eg. German, French, Spanish etc ...

[English strings, for the web UI](https://github.com/patrikx3/redis-ui-material/blob/master/src/strings/en/strings.js)
[English strings, for the Electron](https://github.com/patrikx3/redis-ui/blob/master/src/strings/en/index.js)

For a new language:
Add into `redis-ui-material/src/bundle.js`.

This solution is not using REST at all, but instead uses Socket.IO 🤣, which is weird, but I like it, it is supposed to be more responsive, as there is no big overhead in the HTTP protocol.

### Reference for Socket.IO speed
https://www.google.com/search?q=rest+vs+websocket+comparison+benchmarks

# URL links

[P3X Redis UI playground](https://www.patrikx3.com/en/front/playground/19/p3x-reds-ui#PG19)

[Corifeus P3X Redis UI](https://corifeus.com/redis-ui/)

[AlternativeTo Redis UI](https://alternativeto.net/software/p3x-redis-ui/)

[NPM P3X Redis UI](https://www.npmjs.com/package/p3x-redis-ui)

[Snap Store](https://snapcraft.io/p3x-redis-ui)

[Github.IO Page](https://patrikx3.github.io/redis-ui/)

[//]: #@corifeus-footer

---

🙏 This is an open-source project. Star this repository, if you like it, or even donate to maintain the servers and the development. Thank you so much!

Possible, this server, rarely, is down, please, hang on for 15-30 minutes and the server will be back up.

All my domains ([patrikx3.com](https://patrikx3.com) and [corifeus.com](https://corifeus.com)) could have minor errors, since I am developing in my free time. However, it is usually stable.

**Note about versioning:** Versions are cut in Major.Minor.Patch schema. Major is always the current year. Minor is either 4 (January - June) or 10 (July - December). Patch is incremental by every build. If there is a breaking change, it should be noted in the readme.

---

[**P3X-REDIS-UI**](https://corifeus.com/redis-ui) Build v2023.10.246

[![Donate for Corifeus / P3X](https://img.shields.io/badge/Donate-Corifeus-003087.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=QZVM4V6HVZJW6)  [![Contact Corifeus / P3X](https://img.shields.io/badge/Contact-P3X-ff9900.svg)](https://www.patrikx3.com/en/front/contact) [![Like Corifeus @ Facebook](https://img.shields.io/badge/LIKE-Corifeus-3b5998.svg)](https://www.facebook.com/corifeus.software)

[//]: #@corifeus-footer:end


text:
# Custom Fees Guide

Our dapp no longer limits the user to using solely the Interlay (and Kintsugi) native token (INTR/KINT) to pay transaction fees. Any asset listed in the AMM pools can now be used to pay for transaction fees.

Under the hood, the selected fee token (e.g., DOT) is swapped into the native token (e.g., INTR) to cover fees.

You can select the fee token on every transaction via a "Fee token" selector on each part of the app where you can make a transaction.

![Custom Fees Select](../_assets/img/guide/custom-fees-select.png)

When you click inside the "Fee token" selector, a modal with the available options for pays fees is shown. This modal shows your balance of each token (not the fees you would pay in the token).

![Custom Fees Modal](../_assets/img/guide/custom-fees-select-modal.png)

After inserting all information for the transaction and selecting the fee token, the app will give an estimate on how much fees you will have to pay in the selected fee token.

![Custom Fees Estimate](../_assets/img/guide/custom-fees-estimate.png)

When completing the inputs, an estimation of the fees is provided. Please ensure that you have enough tokens to cover for fees in at least one of the available fee tokens. If you need to add more tokens, please check the [asset onramp guide](/guides/assets).

![Custom Fees Error](../_assets/img/guide/custom-fees-error.png)

gha_language: Shell


text:
# 1Digit7SegLib
A short Arduino-based program that flashes each number on a 1 digit 7 segment display.
Copy the code into your own programs to have numbers 0-9. This eliminates having to use the SevSeg library and not being able to use delays.