text:
<!-- markdown-link-check-disable -->

# Configuration

## Preface

This document explains the DolphinScheduler application configurations.

## Directory Structure

The directory structure of DolphinScheduler is as follows:

```
├── LICENSE
│
├── NOTICE
│
├── licenses                                    directory of licenses
│
├── bin                                         directory of DolphinScheduler application commands, configurations scripts
│   ├── dolphinscheduler-daemon.sh              script to start or shut down DolphinScheduler application
│   ├── env                                     directory of scripts to load environment variables
│   │   ├── dolphinscheduler_env.sh             script to export environment variables [eg: JAVA_HOME,HADOOP_HOME, HIVE_HOME ...] when you start or stop service using script `dolphinscheduler-daemon.sh`
│   │   └── install_env.sh                      script to export environment variables for DolphinScheduler installation when you use scripts `install.sh` `start-all.sh` `stop-all.sh` `status-all.sh`
│   ├── install.sh                              script to auto-setup services when you deploy DolphinScheduler in `psuedo-cluster` mode or `cluster` mode
│   ├── remove-zk-node.sh                       script to cleanup ZooKeeper caches
│   ├── scp-hosts.sh                            script to copy installation files to target hosts
│   ├── start-all.sh                            script to start all services when you deploy DolphinScheduler in `psuedo-cluster` mode or `cluster` mode
│   ├── status-all.sh                           script to check the status of all services when you deploy DolphinScheduler in `psuedo-cluster` mode or `cluster` mode
│   └── stop-all.sh                             script to shut down all services when you deploy DolphinScheduler in `psuedo-cluster` mode or `cluster` mode
│
├── alert-server                                directory of DolphinScheduler alert-server commands, configurations scripts and libs
│   ├── bin
│   │   └── start.sh                            script to start DolphinScheduler alert-server
│   ├── conf
│   │   ├── application.yaml                    configurations of alert-server
│   │   ├── bootstrap.yaml                      configurations for Spring Cloud bootstrap, mostly you don't need to modify this,
│   │   ├── common.properties                   configurations of common-service like storage, credentials, etc.
│   │   ├── dolphinscheduler_env.sh             script to load environment variables for alert-server
│   │   └── logback-spring.xml                  configurations of alert-service log
│   └── libs                                    directory of alert-server libs
│
├── api-server                                  directory of DolphinScheduler api-server commands, configurations scripts and libs
│   ├── bin
│   │   └── start.sh                            script to start DolphinScheduler api-server
│   ├── conf
│   │   ├── application.yaml                    configurations of api-server
│   │   ├── bootstrap.yaml                      configurations for Spring Cloud bootstrap, mostly you don't need to modify this,
│   │   ├── common.properties                   configurations of common-service like storage, credentials, etc.
│   │   ├── dolphinscheduler_env.sh             script to load environment variables for api-server
│   │   └── logback-spring.xml                  configurations of api-service log
│   ├── libs                                    directory of api-server libs
│   └── ui                                      directory of api-server related front-end web resources
│
├── master-server                               directory of DolphinScheduler master-server commands, configurations scripts and libs
│   ├── bin
│   │   └── start.sh                            script to start DolphinScheduler master-server
│   ├── conf
│   │   ├── application.yaml                    configurations of master-server
│   │   ├── bootstrap.yaml                      configurations for Spring Cloud bootstrap, mostly you don't need to modify this,
│   │   ├── common.properties                   configurations of common-service like storage, credentials, etc.
│   │   ├── dolphinscheduler_env.sh             script to load environment variables for master-server
│   │   └── logback-spring.xml                  configurations of master-service log
│   └── libs                                    directory of master-server libs
│
├── standalone-server                           directory of DolphinScheduler standalone-server commands, configurations scripts and libs
│   ├── bin
│   │   └── start.sh                            script to start DolphinScheduler standalone-server
│   ├── conf
│   │   ├── application.yaml                    configurations of standalone-server
│   │   ├── bootstrap.yaml                      configurations for Spring Cloud bootstrap, mostly you don't need to modify this,
│   │   ├── common.properties                   configurations of common-service like storage, credentials, etc.
│   │   ├── dolphinscheduler_env.sh             script to load environment variables for standalone-server
│   │   ├── logback-spring.xml                  configurations of standalone-service log
│   │   └── sql                                 .sql files to create or upgrade DolphinScheduler metadata
│   ├── libs                                    directory of standalone-server libs
│   └── ui                                      directory of standalone-server related front-end web resources
│
├── tools                                       directory of DolphinScheduler metadata tools commands, configurations scripts and libs
│   ├── bin
│   │   └── upgrade-schema.sh                   script to initialize or upgrade DolphinScheduler metadata
│   ├── conf
│   │   ├── application.yaml                    configurations of tools
│   │   └── common.properties                   configurations of common-service like storage, credentials, etc.
│   ├── libs                                    directory of tool libs
│   └── sql                                     .sql files to create or upgrade DolphinScheduler metadata
│
├── worker-server                               directory of DolphinScheduler worker-server commands, configurations scripts and libs
│       ├── bin
│       │   └── start.sh                        script to start DolphinScheduler worker-server
│       ├── conf
│       │   ├── application.yaml                configurations of worker-server
│       │   ├── bootstrap.yaml                  configurations for Spring Cloud bootstrap, mostly you don't need to modify this,
│       │   ├── common.properties               configurations of common-service like storage, credentials, etc.
│       │   ├── dolphinscheduler_env.sh         script to load environment variables for worker-server
│       │   └── logback-spring.xml              configurations of worker-service log
│       └── libs                                directory of worker-server libs
│
└── ui                                          directory of front-end web resources
```

## Configurations in Details

### dolphinscheduler-daemon.sh [startup or shutdown DolphinScheduler application]

dolphinscheduler-daemon.sh is responsible for DolphinScheduler startup and shutdown.
Essentially, start-all.sh or stop-all.sh startup and shutdown the cluster via dolphinscheduler-daemon.sh.
Currently, DolphinScheduler just makes a basic config, remember to config further JVM options based on your practical situation of resources.

Default simplified parameters are:

```bash
export DOLPHINSCHEDULER_OPTS="
-server
-Xmx16g
-Xms1g
-Xss512k
-XX:+UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:+UseFastAccessorMethods
-XX:+UseCMSInitiatingOccupancyOnly
-XX:CMSInitiatingOccupancyFraction=70
"
```

> "-XX:DisableExplicitGC" is not recommended due to may lead to memory link (DolphinScheduler dependent on Netty to communicate).

### Database connection related configuration

DolphinScheduler uses Spring Hikari to manage database connections, configuration file location:

|Service| Configuration file  |
|--|--|
|Master Server | `master-server/conf/application.yaml`|
|Api Server| `api-server/conf/application.yaml`|
|Worker Server| `worker-server/conf/application.yaml`|
|Alert Server| `alert-server/conf/application.yaml`|

The default configuration is as follows:

|Parameters | Default value| Description|
|--|--|--|
|spring.datasource.driver-class-name| org.postgresql.Driver |datasource driver|
|spring.datasource.url| jdbc:postgresql://<IP_ADDRESS>:5432/dolphinscheduler |datasource connection url|
|spring.datasource.username|root|datasource username|
|spring.datasource.password|root|datasource password|
|spring.datasource.hikari.connection-test-query|select 1|validate connection by running the SQL|
|spring.datasource.hikari.minimum-idle| 5| minimum connection pool size number|
|spring.datasource.hikari.auto-commit|true|whether auto commit|
|spring.datasource.hikari.pool-name|DolphinScheduler|name of the connection pool|
|spring.datasource.hikari.maximum-pool-size|50| maximum connection pool size number|
|spring.datasource.hikari.connection-timeout|30000|connection timeout|
|spring.datasource.hikari.idle-timeout|600000|Maximum idle connection survival time|
|spring.datasource.hikari.leak-detection-threshold|0|Connection leak detection threshold|
|spring.datasource.hikari.initialization-fail-timeout|1|Connection pool initialization failed timeout|

Note that DolphinScheduler also supports database configuration through `bin/env/dolphinscheduler_env.sh`.

### Zookeeper related configuration

DolphinScheduler uses Zookeeper for cluster management, fault tolerance, event monitoring and other functions. Configuration file location:
|Service| Configuration file  |
|--|--|
|Master Server | `master-server/conf/application.yaml`|
|Api Server| `api-server/conf/application.yaml`|
|Worker Server| `worker-server/conf/application.yaml`|

The default configuration is as follows:

|Parameters | Default value| Description|
|--|--|--|
|registry.zookeeper.namespace|dolphinscheduler|namespace of zookeeper|
|registry.zookeeper.connect-string|localhost:2181| the connection string of zookeeper|
|registry.zookeeper.retry-policy.base-sleep-time|60ms|time to wait between subsequent retries|
|registry.zookeeper.retry-policy.max-sleep|300ms|maximum time to wait between subsequent retries|
|registry.zookeeper.retry-policy.max-retries|5|maximum retry times|
|registry.zookeeper.session-timeout|30s|session timeout|
|registry.zookeeper.connection-timeout|30s|connection timeout|
|registry.zookeeper.block-until-connected|600ms|waiting time to block until the connection succeeds|
|registry.zookeeper.digest|{username}:{password}|digest of zookeeper to access znode, works only when acl is enabled, for more details please check [https://zookeeper.apache.org/doc/r3.4.14/zookeeperAdmin.html](Apache Zookeeper doc) |

Note that DolphinScheduler also supports zookeeper related configuration through `bin/env/dolphinscheduler_env.sh`.

### common.properties [hadoop、s3、yarn config properties]

Currently, common.properties mainly configures Hadoop,s3a related configurations. Configuration file location:

|Service| Configuration file  |
|--|--|
|Master Server | `master-server/conf/common.properties`|
|Api Server| `api-server/conf/common.properties`|
|Worker Server| `worker-server/conf/common.properties`|
|Alert Server| `alert-server/conf/common.properties`|

The default configuration is as follows:

| Parameters | Default value | Description |
|--|--|--|
|data.basedir.path | /tmp/dolphinscheduler | local directory used to store temp files|
|resource.storage.type | NONE | type of resource files: HDFS, S3, OSS, GCS, ABS, NONE|
|resource.upload.path | /dolphinscheduler | storage path of resource files|
|aws.access.key.id | minioadmin | access key id of S3|
|aws.secret.access.key | minioadmin | secret access key of S3|
|aws.region | us-east-1 | region of S3|
|aws.s3.endpoint | http://minio:9000 | endpoint of S3|
|hdfs.root.user | hdfs | configure users with corresponding permissions if storage type is HDFS|
|fs.defaultFS | hdfs://mycluster:8020 | If resource.storage.type=S3, then the request url would be similar to 's3a://dolphinscheduler'. Otherwise if resource.storage.type=HDFS and hadoop supports HA, copy core-site.xml and hdfs-site.xml into 'conf' directory|
|hadoop.security.authentication.startup.state | false | whether hadoop grant kerberos permission|
|java.security.krb5.conf.path | /opt/krb5.conf | kerberos config directory|
|login.user.keytab.username |<EMAIL_ADDRESS>| kerberos username|
|login.user.keytab.path | /opt/hdfs.headless.keytab | kerberos user keytab|
|kerberos.expire.time | 2 | kerberos expire time,integer,the unit is hour|
|yarn.resourcemanager.ha.rm.ids | 192.168.xx.xx,192.168.xx.xx | specify the yarn resourcemanager url. if resourcemanager supports HA, input HA IP addresses (separated by comma), or input null for standalone|
|yarn.application.status.address | http://ds1:8088/ws/v1/cluster/apps/%s | keep default if ResourceManager supports HA or not use ResourceManager, or replace ds1 with corresponding hostname if ResourceManager in standalone mode|
|development.state | false | specify whether in development state|
|dolphin.scheduler.network.interface.preferred | NONE | display name of the network card|
|dolphin.scheduler.network.priority.strategy | default | IP acquisition strategy, give priority to finding the internal network or the external network|
|resource.manager.httpaddress.port | 8088 | the port of resource manager|
|yarn.job.history.status.address | http://ds1:19888/ws/v1/history/mapreduce/jobs/%s | job history status url of yarn|
|datasource.encryption.enable | false | whether to enable datasource encryption|
|datasource.encryption.salt | !@#$%^&* | the salt of the datasource encryption|
|data-quality.jar.name | dolphinscheduler-data-quality-dev-SNAPSHOT.jar | the jar of data quality|
|support.hive.oneSession | false | specify whether hive SQL is executed in the same session|
|sudo.enable | true | whether to enable sudo|
|alert.rpc.port | 50052 | the RPC port of Alert Server|
|zeppelin.rest.url | http://localhost:8080 | the RESTful API url of zeppelin|
|appId.collect | log | way to collect applicationId, if use aop, alter the configuration from log to aop, annotation of applicationId auto collection related configuration in `bin/env/dolphinscheduler_env.sh` should be removed. Note: Aop way doesn't support submitting yarn job on remote host by client mode like Beeline, and will failure if override applicationId collection-related environment configuration in dolphinscheduler_env.sh, and .|

### Api-server related configuration

Location: `api-server/conf/application.yaml`

|Parameters | Default value| Description|
|--|--|--|
|server.port|12345|api service communication port|
|server.servlet.session.timeout|120m|session timeout|
|server.servlet.context-path|/dolphinscheduler/ |request path|
|spring.servlet.multipart.max-file-size|1024MB|maximum file size|
|spring.servlet.multipart.max-request-size|1024MB|maximum request size|
|server.jetty.max-http-post-size|5000000|jetty maximum post size|
|spring.banner.charset|UTF-8|message encoding|
|spring.jackson.time-zone|UTC|time zone|
|spring.jackson.date-format|"yyyy-MM-dd HH:mm:ss"|time format|
|spring.messages.basename|i18n/messages|i18n config|
|security.authentication.type|PASSWORD|authentication type|
|security.authentication.ldap.user.admin|read-only-admin|admin user account when you log-in with LDAP|
|security.authentication.ldap.urls|ldap://ldap.forumsys.com:389/|LDAP urls|
|security.authentication.ldap.base.dn|dc=example,dc=com|LDAP base dn|
|security.authentication.ldap.username|cn=read-only-admin,dc=example,dc=com|LDAP username|
|security.authentication.ldap.password|password|LDAP password|
|security.authentication.ldap.user.identity-attribute|uid|LDAP user identity attribute|
|security.authentication.ldap.user.email-attribute|mail|LDAP user email attribute|
|security.authentication.ldap.user.not-exist-action|CREATE|action when ldap user is not exist,default value: CREATE. Optional values include(CREATE,DENY)|
|security.authentication.ldap.ssl.enable|false|LDAP switch|
|security.authentication.ldap.ssl.trust-store|ldapkeystore.jks|LDAP jks file absolute path|
|security.authentication.ldap.ssl.trust-store-password|password|LDAP jks password|
|traffic.control.global.switch|false|traffic control global switch|
|traffic.control.max-global-qps-rate|300|global max request number per second|
|traffic.control.tenant-switch|false|traffic control tenant switch|
|traffic.control.default-tenant-qps-rate|10|default tenant max request number per second|
|traffic.control.customize-tenant-qps-rate||customize tenant max request number per second|

### Master Server related configuration

Location: `master-server/conf/application.yaml`

|Parameters | Default value| Description|
|--|--|--|
|master.listen-port|5678|master listen port|
|master.fetch-command-num|10|the number of commands fetched by master|
|master.pre-exec-threads|10|master prepare execute thread number to limit handle commands in parallel|
|master.exec-threads|100|master execute thread number to limit process instances in parallel|
|master.dispatch-task-number|3|master dispatch task number per batch|
|master.host-selector|lower_weight|master host selector to select a suitable worker, default value: LowerWeight. Optional values include random, round_robin, lower_weight|
|master.heartbeat-interval|10|master heartbeat interval, the unit is second|
|master.task-commit-retry-times|5|master commit task retry times|
|master.task-commit-interval|1000|master commit task interval, the unit is millisecond|
|master.state-wheel-interval|5|time to check status|
|master.max-cpu-load-avg|1|master max cpuload avg percentage, only higher than the system cpu load average, master server can schedule. default value 1: will use 100% cpu|
|master.reserved-memory|0.3|master reserved memory, only lower than system available memory, master server can schedule. default value 0.3, only the available memory is higher than 30%, master server can schedule.|
|master.failover-interval|10|failover interval, the unit is minute|
|master.kill-application-when-task-failover|true|whether to kill yarn/k8s application when failover taskInstance|
|master.registry-disconnect-strategy.strategy|stop|Used when the master disconnect from registry, default value: stop. Optional values include stop, waiting|
|master.registry-disconnect-strategy.max-waiting-time|100s|Used when the master disconnect from registry, and the disconnect strategy is waiting, this config means the master will waiting to reconnect to registry in given times, and after the waiting times, if the master still cannot connect to registry, will stop itself, if the value is 0s, the Master will wait infinitely|
|master.worker-group-refresh-interval|10s|The interval to refresh worker group from db to memory|

### Worker Server related configuration

Location: `worker-server/conf/application.yaml`

|Parameters | Default value| Description|
|--|--|--|
|worker.listen-port|1234|worker-service listen port|
|worker.exec-threads|100|worker-service execute thread number, used to limit the number of task instances in parallel|
|worker.heartbeat-interval|10|worker-service heartbeat interval, the unit is second|
|worker.host-weight|100|worker host weight to dispatch tasks|
|worker.tenant-auto-create|true|tenant corresponds to the user of the system, which is used by the worker to submit the job. If system does not have this user, it will be automatically created after the parameter worker.tenant.auto.create is true.|
|worker.max-cpu-load-avg|1|worker max cpuload avg, only higher than the system cpu load average, worker server can be dispatched tasks. default value 1: will use 100% cpu.|
|worker.reserved-memory|0.3|worker reserved memory, only lower than system available memory, worker server can be dispatched tasks. default value 0.3, only the available memory is higher than 30%, worker server can receive task.|
|worker.alert-listen-host|localhost|the alert listen host of worker|
|worker.alert-listen-port|50052|the alert listen port of worker|
|worker.registry-disconnect-strategy.strategy|stop|Used when the worker disconnect from registry, default value: stop. Optional values include stop, waiting|
|worker.registry-disconnect-strategy.max-waiting-time|100s|Used when the worker disconnect from registry, and the disconnect strategy is waiting, this config means the worker will waiting to reconnect to registry in given times, and after the waiting times, if the worker still cannot connect to registry, will stop itself, if the value is 0s, will wait infinitely |
|worker.task-execute-threads-full-policy|REJECT|If REJECT, when the task waiting in the worker reaches exec-threads, it will reject the received task and the Master will redispatch it; If CONTINUE, it will put the task into the worker's execution queue and wait for a free thread to start execution|

### Alert Server related configuration

Location: `alert-server/conf/application.yaml`

|Parameters | Default value| Description|
|--|--|--|
|server.port|50053|the port of Alert Server|
|alert.port|50052|the port of alert|

### Quartz related configuration

This part describes quartz configs and configure them based on your practical situation and resources.

|Service| Configuration file  |
|--|--|
|Master Server | `master-server/conf/application.yaml`|
|Api Server| `api-server/conf/application.yaml`|

The default configuration is as follows:

|                               Parameters                                |                  Default value                  |
|-------------------------------------------------------------------------|-------------------------------------------------|
| spring.quartz.properties.org.quartz.jobStore.isClustered                | true                                            |
| spring.quartz.properties.org.quartz.jobStore.class                      | org.quartz.impl.jdbcjobstore.JobStoreTX         |
| spring.quartz.properties.org.quartz.scheduler.instanceId                | AUTO                                            |
| spring.quartz.properties.org.quartz.jobStore.tablePrefix                | QRTZ_                                           |
| spring.quartz.properties.org.quartz.jobStore.acquireTriggersWithinLock  | true                                            |
| spring.quartz.properties.org.quartz.scheduler.instanceName              | DolphinScheduler                                |
| spring.quartz.properties.org.quartz.jobStore.useProperties              | false                                           |
| spring.quartz.properties.org.quartz.jobStore.misfireThreshold           | 60000                                           |
| spring.quartz.properties.org.quartz.scheduler.makeSchedulerThreadDaemon | true                                            |
| spring.quartz.properties.org.quartz.jobStore.driverDelegateClass        | org.quartz.impl.jdbcjobstore.PostgreSQLDelegate |
| spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval     | 5000                                            |

The above configuration items is the same in *Master Server* and *Api Server*, but their *Quartz Scheduler* threadpool configuration is different.

The default quartz threadpool configuration in *Master Server* is as follows:

|                            Parameters                             |           Default value           |
|-------------------------------------------------------------------|-----------------------------------|
| spring.quartz.properties.org.quartz.threadPool.makeThreadsDaemons | true                              |
| spring.quartz.properties.org.quartz.threadPool.threadCount        | 25                                |
| spring.quartz.properties.org.quartz.threadPool.threadPriority     | 5                                 |
| spring.quartz.properties.org.quartz.threadPool.class              | org.quartz.simpl.SimpleThreadPool |

Since *Api Server* will not start *Quartz Scheduler* instance, as a client only, therefore it's threadpool is configured as `QuartzZeroSizeThreadPool` which has zero thread;
The default configuration is as follows:

|                      Parameters                      |                             Default value                             |
|------------------------------------------------------|-----------------------------------------------------------------------|
| spring.quartz.properties.org.quartz.threadPool.class | org.apache.dolphinscheduler.scheduler.quartz.QuartzZeroSizeThreadPool |

### dolphinscheduler_env.sh [load environment variables configs]

When using shell to commit tasks, DolphinScheduler will export environment variables from `bin/env/dolphinscheduler_env.sh`. The
mainly configuration including `JAVA_HOME` and other environment paths.

```bash
# JAVA_HOME, will use it to start DolphinScheduler server
export JAVA_HOME=${JAVA_HOME:-/opt/soft/java}

# Tasks related configurations, need to change the configuration if you use the related tasks.
export HADOOP_HOME=${HADOOP_HOME:-/opt/soft/hadoop}
export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-/opt/soft/hadoop/etc/hadoop}
export SPARK_HOME=${SPARK_HOME:-/opt/soft/spark}
export PYTHON_HOME=${PYTHON_HOME:-/opt/soft/python}
export HIVE_HOME=${HIVE_HOME:-/opt/soft/hive}
export FLINK_HOME=${FLINK_HOME:-/opt/soft/flink}
export DATAX_HOME=${DATAX_HOME:-/opt/soft/datax}

export PATH=$HADOOP_HOME/bin:$SPARK_HOME/bin:$PYTHON_HOME/bin:$JAVA_HOME/bin:$HIVE_HOME/bin:$FLINK_HOME/bin:$DATAX_HOME/bin:$PATH

# applicationId auto collection related configuration, the following configurations are unnecessary if setting appId.collect=log
export HADOOP_CLASSPATH=`hadoop classpath`:${DOLPHINSCHEDULER_HOME}/tools/libs/*
export SPARK_DIST_CLASSPATH=$HADOOP_CLASSPATH:$SPARK_DIST_CLASS_PATH
export HADOOP_CLIENT_OPTS="-javaagent:${DOLPHINSCHEDULER_HOME}/tools/libs/aspectjweaver-1.9.7.jar":$HADOOP_CLIENT_OPTS
export SPARK_SUBMIT_OPTS="-javaagent:${DOLPHINSCHEDULER_HOME}/tools/libs/aspectjweaver-1.9.7.jar":$SPARK_SUBMIT_OPTS
export FLINK_ENV_JAVA_OPTS="-javaagent:${DOLPHINSCHEDULER_HOME}/tools/libs/aspectjweaver-1.9.7.jar":$FLINK_ENV_JAVA_OPTS
```

### Log related configuration

|Service| Configuration file  |
|--|--|
|Master Server | `master-server/conf/logback-spring.xml`|
|Api Server| `api-server/conf/logback-spring.xml`|
|Worker Server| `worker-server/conf/logback-spring.xml`|
|Alert Server| `alert-server/conf/logback-spring.xml`|

repository: RebieKong/EasyScheduler

repo_name: RebieKong/EasyScheduler


text:
---
ENTRYTYPE: inproceedings
abstract: 'Side-channel attacks that leak sensitive information through a computing device''s interaction with its physical environment have proven to be
  a severe threat to devices'' security, particularly when adversaries have unfettered physical access to the device. Traditional approaches for leakage
  detection measure the physical properties of the device. Hence, they cannot be used during the design process and fail to provide root cause analysis.
  An alternative approach that is gaining traction is to automate leakage detection by modeling the device. The demand to understand the scope, benefits,
  and limitations of the proposed tools intensifies with the increase in the number of proposals. In this SoK, we classify approaches to automated leakage
  detection based on the model''s source of truth. We classify the existing tools on two main parameters: whether the model includes measurements from a
  concrete device and the abstraction level of the device specification used for constructing the model. We survey the proposed tools to determine the current
  knowledge level across the domain and identify open problems. In particular, we highlight the absence of evaluation methodologies and metrics that would
  compare proposals'' effectiveness from across the domain. We believe that our results help practitioners who want to use automated leakage detection and
  researchers interested in advancing the knowledge and improving automated leakage detection.'
added: 2022-08-20
address: New York, NY, USA
authors:
- Ileana Buhan
- Lejla Batina
- Yuval Yarom
- Patrick Schaumont
booktitle: Proceedings of the 2022 ACM on Asia Conference on Computer and Communications Security
doi: 10.1145/3488932.3517415
isbn: '9781450391405'
keywords: power analysis, side-channel, emulators
layout: paper
link: https://doi.org/10.1145/3488932.3517415
location: Nagasaki, Japan
numpages: '15'
pages: 756-770
publisher: Association for Computing Machinery
read: false
readings: []
series: ASIA CCS '22
title: 'SoK: Design tools for side-channel-aware implementations'
url: https://doi.org/10.1145/3488932.3517415
year: 2022
notes:
- side-channel
- security
- hardware
papers:
---
{% include links.html %}

license: MIT

repository: alastairreid/RelatedWork

branch_name: refs/heads/main

extension: md

gha_language: TeX

gha_license_id: MIT

license_type: permissive

repo_name: alastairreid/RelatedWork


text:
# FuelChainDAP

Please ensure the following dependencies are installed prior recreating setup
1. GIT
2. Node js
3. Ganache
4. Truffle
5. MetaMask

DEV Environment Background.

Fuelchain POC was developed and tested on clean install of Windows 10 Professional built from an image OS Install CD using VMWare Player.
Please ensure Windows version is @ least 10.0.17134.471
Summarised steps to replicate Fuelchain DAPP enviromment

Check all the the above pre requsites are in stalled

Pull down the files using one of the following 2 options

1. Copy the zip file down and extract into a folder on the root of C:\

2. USE the following GIT command

`git clone https://github.com/dubirl/FuelChainDAP.git`

The will pull the contents into a folder called FuelchainDap under the users\profilename\

Please note: Make sure there are not *.json files in the fuelchaindap\build\contracts prior to initialising FuelChain DAPP

Start up Ganache and ensure that is it running.
From a dos prompt navigate to the \fuelchainDap folder and run the following commands
Truffle.cmd compile
Truffle.cmd migrate
Both command should return logs to indicate the smart contracts compiled and migrated to Ganache
Your Transction Count in Ganache should be 4

Get the mnenonic seed phrase from Ganache (12 words) and copy it to a text file
Open Google Chrome and locate the metamask icon - look for the option import seed from phrase
Copy and paste the mnenoic phrase and set a new password (NOTE PASSWORD for this)
If MetaMask status is Main Network change to custom and enter CUSTOM URL  http://<IP_ADDRESS>:7545
Ensure that the private network appears and check that the ID of the account within metamask matches account
0 in Ganache.

From the command prompt in the \fuelchainDap folder run the following command
npm run dev

The website will initialise.
A MetaMask window will appear and prompt for permission to connect to the FuelChain POC - click connect
MetaMask is now synced with the webpage.
You can interact with the contract by selecing an order and clicking the "confirm order"
MetaMask will appear to confirm the transaction - click confirm and the tranasction will be sent to the smart contract address.
You will tell if the transaction has been sucessful as the count in Ganache will have increased by one.

repository: dubirl/FuelChainDAPP

branch_name: refs/heads/master

repo_name: dubirl/FuelChainDAPP


text:
# Tube Bender

vtkTubeBender is designed to generate better tube paths for vtkTubeFilter.

For points with very sharp inflection point angles, the radius used to determine
where surface points are placed becomes more parallel, instead of perpendicular,
to the tube path. This causes the tube to become more oblong, as the
cross-sectional height and width become increasingly disparate.

This filter inserts new points along the tube path near acute angles to reduce
the amount the point normals will change from point to point. This reduces the
cross-sectional height and width variations from over 95% to less than 30%.
This gives an impression of a constant diameter tube with nice acute angle bends
without adding too many new points (and therefore faces).

repository: EvgenyVRN/VTK

gha_license_id: NOASSERTION

repo_name: EvgenyVRN/VTK


text:
# [![gowww](https://avatars.githubusercontent.com/u/18078923?s=20)](https://github.com/gowww) log [![GoDoc](https://godoc.org/github.com/gowww/log?status.svg)](https://godoc.org/github.com/gowww/log) [![Build](https://travis-ci.org/gowww/log.svg?branch=master)](https://travis-ci.org/gowww/log) [![Coverage](https://coveralls.io/repos/github/gowww/log/badge.svg?branch=master)](https://coveralls.io/github/gowww/log?branch=master) [![Go Report](https://goreportcard.com/badge/github.com/gowww/log)](https://goreportcard.com/report/github.com/gowww/log) ![Status Stable](https://img.shields.io/badge/status-stable-brightgreen.svg)

Package [log](https://godoc.org/github.com/gowww/log) provides a handler that logs each request/response (time, duration, status, method, path).
The log formatting can either be couloured or not.

## Installing

1.  Import it in your code:

	```Go
	import "github.com/gowww/log"
	```

## Usage

To wrap an [http.Handler](https://golang.org/pkg/net/http/#Handler), use [Handle](https://godoc.org/github.com/gowww/log#Handle):

```Go
mux := http.NewServeMux()

mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello")
})

http.ListenAndServe(":8080", log.Handle(mux, nil))
```

To wrap an [http.HandlerFunc](https://golang.org/pkg/net/http/#HandlerFunc), use [HandleFunc](https://godoc.org/github.com/gowww/log#HandleFunc):

```Go
http.Handle("/", log.HandleFunc(func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello")
}, nil))

http.ListenAndServe(":8080", nil)
```

All in all, make sure to include this handler above any other handler to get accurate performance logs.

repository: gowww/log

repo_name: gowww/log


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

Patrick Mogianesi, a graduating Bioengineering student from University of California, Santa Cruz with an interest in technical problem solving, coding and embedded systems.

### More Information
I have a Bachelors of Science in Bioengineering where I opted for the bioelectronics concentration, while there I learned the essentials of circuit analysis of RLC and transistor circuits and a heap of classes on embedded systems. I have experience with the PIC32 architecture, Arduino, and Verilog. During my senior capstone I wrote the driving code for packet communication between a PC and MCU that used CRC-8 data integrity checks. On the PC and MCU I wrote the packet protocol system. I worked with two other teammates on establishing a GUI interface using the Python Tkinter library, where I directed the technical implementation of the widgets. The repository for this work can be seen [here](https://github.com/quail-mail/googun).

The GUI work also led me to REALLY learn how to use Git when working on the projects with others. In order solve git management, short SCRUM meetings were implemented for updates on progress and merging feature branches that allowed for accelerated progress towards the end of the project.

### Contact me

[pmogianesi<EMAIL_ADDRESS>


text:
# Phlash

![Image](files/graphics/phlash-logo-small.png?raw=true)

Phlash is a very simple PHP flash messages library. Phlash does not define how your flash messages look or whether you use javascript to close them or not. Instead, Phlash just provides the very raw tools to quickly add and get flash messages.

## Requirements

* PHP 5.6+

## Features

* Flash messages
    * Add one or more flash messages with a type
        * Define your own types like warning, info, danger or anything you desire
    * Get
        * Get your flash messages to show in a view
        * Render any way you like including choosing your own div layouts and naming conventions
    * Clear
        * Clear the flash messages after they have been shown

## Installation

The reccomended way to install is via Composer.

Ensure your minimum-stability is set to dev:

```shell
$ composer require artbyrab/phlash
```

or add it to your composer.json file:

```json
"artbyrab/phlash": "master@dev"
```

## Usage

Ensure your view or entry script has php sessions activated:

```php
session_start();
```

Add one or more flash messages in your controller action or file:

```php
use artbyrab\phlash\Phlash;

Phlash::add("info", "This is Phlash!");
Phlash::add("success", "Your message was successful!");
Phlash::add("warning", "Be careful though, using Phlash can be addictive!");
Phlash::add("danger", "See it's hard to stop!");
```

Add a way to render the flash messages in your view/layout or file. Please note the below is just an example of how you can render your flash messages, you don't need to use the below format:

```html
<?php if (Phlash::get() !== false) { ?>

    <div class="alerts">

        <?php foreach (Phlash::get() as $flash) { ?>

            <div class="alert alert--<?=$flash->type?>">

                <div class="alert__message">
                    <?=$flash->message?>
                </div>

                <div class="alert__close">
                    <a href="#" class="close" data-dismiss="alert" aria-label="close" title="close">×</a>
                </div>
            </div>

        <?php }; ?>

        <?php Phlash::clear(); ?>

    </div>

<?php }; ?>
```

For more information on using Phlash have a read of the documentation and guides:

## Resources

* [Code Checks](documents/code-checks.md)
* [Dismissable Messages](documents/dismissable-messages.md)
* [Example](documents/example.md)
* [Flash message types](documents/flash-message-types.md)
* [PHP Compatability Checks](documents/php-compatability-checks.md)
* [Running Tests](documents/running-tests.md)
* [Starting a PHP session](documents/starting-a-php-session.md)

repository: artbyrab/phlash

repo_name: artbyrab/phlash


text:
---
layout: default
title: Trade Lifecycle
parent: Trading Guide
nav_order: 1
---

# Trading Guide

## Trade lifecycle

### Funding exchange wallet

Bitcoin is the currency of transactions on Delta. This means that margins and PnL on Delta are denominated in Bitcoins. Before you are able to trade, you need to fund your exchange wallet with Bitcoins. You can see detail on how to deposit/ withdraw Bitcoins from your Delta wallet on the **Account Details** page.

 ### Placing an order

Orders can be placed in Place Order Panel in the trading dashboard. We currently support three types of order:

  -   **Limit order:** is an order to buy or sell a specified number of derivative contracts at a specified price. A limit order will only ever fill at the specified price or better price.

-   **Market order:** is an order to buy or sell a specified number of derivative contracts at the best available price available in the order book. There is no guarantee that a market order will fill at the price specified. A market order may fill at a number of different prices, based on the quantity of the market order and the quantities of the existing orders on the order book at the time.
- **Stop order:** write text here

### Margin & PnL Calculations

A new order is allowed to be submitted to the exchange only if the trader has sufficient balance available to reserve the order margin. Order margin computation happens in one of the two ways:

-   Trader doesn’t have an existing position in the contract: the system computes the initial margin that would be required if this position is acquired. This is the amount that is blocked as order margin.

-   Trader has an existing position in the contract: in this case, the system computes the margin required for the updated overall position after the placed order has been executed. The difference between this computed margin requirement and the current position margin is what is additionally needed for this order. This is the amount that is block as order margin. [fair price](#fpm)

Details on the various types of margins and their calculations are available [here](#marginexplain).

Existing positions on Delta are marked at [fair Price](#fpm). This means that your unrealised PnL and hence the current value of margin allocated to a particular position are a function of the marked price. PnL calculations are illustrated with example in the [PnL Math](#pnlmath) section.

### Settlement

You can square off a position in a derivatives contract in the exchange. Position that are held till maturity are cash settled at a price that is computed using the settlement method described in the [contract specifications](https://delta.exchange/contracts).


text:
**New Year's Day双手简谱** 和五线谱完全对应。

_New Year's Day_ 是由美国创作型女歌手Taylor
Swift演唱的歌曲。该歌曲收录在泰勒•斯威夫特2017年11月10日发行的第六张录音室专辑《Reputation》中。

Reputation不仅是泰勒•斯威夫特的原创心血，更意味着她华丽转身，霸气回归，这张专辑就像是她给全世界的一张宣誓词。不同于过往色彩大胆、轻松跳跃的风格，此次专辑封面为黑白照片，显得较为压抑。照片中泰勒穿着一件露肩T恤，右半边脸部被各种印有她名字的报道字体覆盖，脖子上则是套着看起来有些过紧的链子，似乎在表达对外界给她“名声（Reputation）”的回应。2018年5月21日，该专辑获得公告牌音乐奖最佳畅销专辑奖。

歌词下方是 _New Year's Day钢琴谱_ ，大家可以免费下载学习。

### New Year's Day歌词：

There's glitter on the floor after the party
Girls carrying their shoes down in the lobby
Candle wax and Polaroids on the hardwood floor
You and me from the night before but
Don't read the last page
But I stay when you're lost and I'm scared
And you're turning away
I want your midnights
But I'll be cleaning up bottles with you on New Year's Day
You squeeze my hand three times in the back of the taxi
I can tell that it's gonna be a long road
I'll be there if you're the toast of the town babe
Or if you strike out and you're crawling home
Don't read the last page
But I stay when it's hard or it's wrong
Or we're making mistakes
I want your midnights
But I'll be cleaning up bottles with you on New Year's Day
Hold on to the memories they will hold on to you
Hold on to the memories they will hold on to you
Hold on to the memories they will hold on to you
And I will hold on to you
Please don't ever become a stranger
Whose laugh I could recognize anywhere
Please don't ever become a stranger
Whose laugh I could recognize anywhere
There's glitter on the floor after the party
Girls carrying their shoes down in the lobby
Candle wax and Polaroids on the hardwood floor
You and me forevermore
Don't read the last page
But I stay when it's hard or it's wrong
Or we're making mistakes
I want your midnights
But I'll be cleaning up bottles with you on New Year's Day
Hold on to the memories they will hold on to you
Hold on to the memories they will hold on to you
Hold on to the memories they will hold on to you
And I will hold on to you
Please don't ever become a stranger
Whose laugh I could recognize anywhere
Please don't ever become a stranger
Whose laugh I could recognize anywhere

path: /流行/New Year's Day-Taylor Swift/README.md


text:
# Commands - API

The basic flow of an API command is as follows:

- API command *(`bin/run apis <my-command>`)*
    - **Command** *(Configure Adapter & Connectors, executes Adapter with required arguments)*
        - **Adapter** *(Executes injected Connector with necassary arguments for a single payload)*
            - **Connector** *(Queries/Requests response)*
                - Third Party API/DB/Service (Recieves a payload)
            - **Connector** *(Deliver payload to Adapter, optionally with features to convert from XML/CSV into JSON for `TapjawMessage.payload`)*
        - **Adapter** *(Decode and yield each `TapjawMessage`)*
        - **StdoutIterator** *(Convert the `TapjawMessage` to JSON and output to STDOUT buffer)*

repository: digidip/tapjaw-importer

gha_language: TypeScript

repo_name: digidip/tapjaw-importer


text:
---
id: getting-started
title: "Getting Started"
---

ZIO Process - a purely functional command and process library based on ZIO.
Here's list of contents available:

 - **[Basics](basics.md)** — Creating a description of a command and transforming its output
 - **[Piping](piping.md)** — Creating a pipeline of commands
 - **[Interactive Processes](interactive-processes.md)** — Communicating with an interactive process
 - **[Other](other.md)** — Miscellaneous operations such as settings the working direction, inheriting I/O, etc.

## Installation

Include ZIO Process in your project by adding the following to your `build.sbt`:

```scala
libraryDependencies += "dev.zio" %% "zio-process" % "@VERSION@"
```

repository: zio/zio-process

gha_language: Scala

repo_name: zio/zio-process


text:
# collision

MD5 is a hash function that checks data integrity.

```
Input (data) -> Function -> Output (hash)
```

Also, MD5 has one limitation called collision. It happens when two different inputs have the same output.

Now, let's start the challenge!

```
:~$ ssh<EMAIL_ADDRESS>-p2222
<EMAIL_ADDRESS>password: guest
```

```
col@prowl:~$ ls
col col.c flag
col@prowl:~$ cat col.c
```

```
#include <string.h>
#include <string.h>
unsigned long hashcode = 0x21DD09EC;
unsigned long check_password(const char* p){
    int* ip = (int*)p;
    int i;
    int res=0;
    for(i=0; i<5; i++){
        res += ip[i];
    }
    return res;
}

int main(int argc, char* argv[]){
    if(argc<2){
        printf("usage : %s [passcode]\n", argv[0]);
        return 0;
    }
    if(strlen(argv[1]) != 20){
        printf("passcode length should be 20 bytes\n");
    }
    if(hashcode == check_password(argv[1])){
        system("/bin/cat flag");
        return 0;
    }
    else
        print("wrong passcode.\n");
        return 0;
}
```

Well, the code says I have to choose one password which has to follow this:

```
0 - 255 (dec)
0 - FF  (hex)
int -> 4 bytes
```

```
res += ip[i]

i = 0;
i = 1;
i = 2;
i = 3;
i = 4;
```

For example, If I have ```01 01 01 01``` ```01 01 01 01``` ```01 01 01 01``` ```01 01 01 01``` ```01 01 01 01```, it means that each i has 4 bytes or  ```01 01 01 01```.

Now, following ```res```, I have to sum all of these i and the final result have to be the same than ```hashcode = 0x21DD09EC```. However, 0x21DD09EC in decimal is 568134124, and it is not divisible by 5 because the result is 113626824.8. Let's use just 113626824 which in hex is 6C5CEC8. So, 113626824 * 4 is 454507296. If we do ```0x21DD09EC``` - 454507296, the result is 113626828 which in hex is 6C5CECC.

Finally, we have 6C5CECC + 6C5CEC8 * 4 == ```0x21DD09EC```

Let's find the flag using python to pass it as an input, and also we have to respect endiannes because the terminal understands this way.

```
col@prowl:~$ ./col $(python -c 'print "\xCC\xCE\xC5\x06" + "\xC8\xCE\xC5\x06" * 4')
```

```
flag here!
```

repository: malucart/pwanble-dot-kr

repo_name: malucart/pwanble-dot-kr


text:
# pyrithm #

Record the notes in the learning process of the alpyrithm, as well as the problem solving methods such as leetcode and etc, with programming language python.


text:
ansible-rabbitmq-minimalistic
=============================
[![Build Status](https://travis-ci.org/marcobellaccini/ansible-rabbitmq-minimalistic.svg?branch=master)](https://travis-ci.org/marcobellaccini/ansible-rabbitmq-minimalistic)

Minimalistic, yet powerful and clustering-enabled RabbitMQ Ansible role.

Written for Debian 10 (may work on other versions and distributions too - in case, please let me know).

Role Variables
--------------
Apart from role defaults (for which you can refer to
[this file](https://github.com/marcobellaccini/ansible-rabbitmq-minimalistic/blob/master/defaults/main.yml)),
you'll probably want to deploy your custom *rabbitmq.conf* file to the servers.

You can make the role generate and deploy your *rabbitmq.conf* file by defining the *rabbitmq_conf_template* variable:

    rabbitmq_conf_template: "path/to/rabbitmq.conf.j2"

The path is relative to the playbook directory.

In this way, you can also deploy a RabbitMQ cluster just by leveraging the
[cluster_formation.classic_config.nodes](https://www.rabbitmq.com/configure.html#config-items) server variable in *rabbitmq.conf*.

For example, you can use a *rabbitmq.conf.j2* template like this:

    {% for host in ansible_play_hosts_all %}
    cluster_formation.classic_config.nodes.{{ loop.index }} = rabbit@{{ hostvars[host]['inventory_hostname'] }}
    {% endfor %}

In order to enable clustering, you will have to setup the hosts with the same [erlang cookie](https://www.rabbitmq.com/clustering.html#erlang-cookie).

For this, you can use the *rabbitmq_erlang_cookie* variable (please consider using
[Ansible Vault](https://docs.ansible.com/ansible/latest/user_guide/vault.html) to encrypt the cookie).

When clustering, you will also have to set *serial: 1* in your playbook (otherwise nodes may experience problems when trying to form the cluster).

You can also enable RabbitMQ plugins by simply specifying and deploying a
RabbitMQ [enabled_plugins file](https://www.rabbitmq.com/plugins.html#ways-to-enable-plugins) from a template:

    rabbitmq_enabled_plugins_template: "path/to/enabled_plugins.j2"

Again, the path is relative to the playbook directory.

For other variables, see [Role Defaults](https://github.com/marcobellaccini/ansible-rabbitmq-minimalistic/blob/master/defaults/main.yml).

This role aims to be minimalistic: in order to perform advanced configurations, you can use
[Ansible RabbitMQ Modules](https://docs.ansible.com/ansible/latest/modules/list_of_messaging_modules.html).

Example Playbook
----------------

    - hosts: msgservers
      serial: 1  # this is required only if you deploy a RabbitMQ cluster
      roles:
         - ansible-rabbitmq-minimalistic
      vars:
        rabbitmq_conf_template: "my_rabbit_conf/rabbitmq.conf.j2"  # this is optional
        rabbitmq_enabled_plugins_template: "my_rabbit_conf/enabled_plugins.j2"  # this is optional
        rabbitmq_erlang_cookie: "XXXXXXXXXXXXXXXXXXXX"  # Required for clustering. NOTE: this is just an example: please use Ansible Vault!

License
-------

Apache License 2.0

Author Information
------------------

Marco Bellaccini - marco.bellaccini[at!]gmail.com

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


text:
# πύλη, ης, ἡ.

<!-- Status: S2=NeedsReview -->
<!-- Lexica used for edits: BDAG, FFM, LN, A-S -->

## Word data

* Strongs: G44390.

* Alternate spellings:

* Principle Parts:

* Part of speech:

[Noun](http://ugg.readthedocs.io/en/latest/noun.html).

* Instances in the New Testament: 10.

* All Scriptures cited: Yes

## Etymology:

* LXX/Hebrew glosses:

in LXX chiefly and very freq. for [שַׁעַר](//en-uhl/H8179) sometimes for [דֶּלֶת](//en-uhl/H1817), [פֶּתַח](//en-uhl/H6607);

* Time Period/Ancient Authors:

* Related words:

* Antonyms for all senses

* Synonyms for all senses:

## Senses

### Sense  1.0:

#### Definition:

gate, door (in Matt. 16:18, used idiomatically of the gates of Hades, likely referring to death and supernatural evil)

#### Glosses:

gate, door

#### Explanation:

#### Citations:

a gate: [Lk 7:12](Luk 7:12), [Ac 9:24](Act 9:24) [12:10](Act 12:10) [16:13](Act 16:13), [He 13:12](Heb 13:12); [ἡ Ὡραία Π. τ. ἱεροῦ](), [Ac 3:10](Act 3:10). Metaph., [Mt 7:13](Mat 7:13), [14](Mat 7:14); [πύλαι ᾅδου]() ([Wi 16:13](Wis.16.13), [III Mac 5:51](3Macc.5.51), and cf. [κλεῖς ᾅδου](), [Re 1:18](Rev 1:18)): [Mt 16:18](Mat 16:18).†

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Azure Infrastructure Operations Project: Deploying a scalable IaaS web server in Azure

### Introduction

This is a project from Udacity Azure DevOps Nanodegree - Deploying a Web Server in Azure. For this project, we will write a Packer template and a Terraform template to deploy a customisable, scalable web server and jumpbox in Azure.

### Prerequisites

Before we begin ensure the following is complete:

1. Create an [Azure Account](https://portal.azure.com)
2. Install the [Azure command line interface](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest)
3. Install [Packer](https://www.packer.io/downloads)
4. Install [Terraform](https://www.terraform.io/downloads.html)

### Instructions

* **vars.tf**: This file holds the values of the variables used in the template.
* **output.tf**: This file describes the settings that display after deployment.
* **main.tf**: This file contains the code of the infrastructure we will be deploying.
* **provider.tf**: This file contains the code for the terraform provider plugin.
* **webserver.json**: This file contains the packer template for building our webserver image.

### Build Packer image

1. Create a resource group with az group create: `az group create -n udacityImageGroup -l uksouth`

```
{
  "id": "/subscriptions/b8acf670-45b1-4124-b6ce-a294c1583634/resourceGroups/udacityImageGroup",
  "location": "uksouth",
  "managedBy": null,
  "name": "udacityImageGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}
```

2. Create a service principal with az ad sp create-for-rbac and output the credentials that Packer needs:

```
az ad sp create-for-rbac --query "{ client_id: appId, client_secret: password, tenant_id: tenant }"
az account show --query "{ subscription_id: id }"
```

```
export ARM_SUBSCRIPTION_ID=your_subscription_id
export ARM_CLIENT_ID=your_appId
export ARM_CLIENT_SECRET=your_password
export ARM_TENANT_ID=your_tenant_id
```

3. Build Image

`packer build webserver.json`

### Deploy the infrastructure

1. Initialise the Terraform environment by running the following command in the directory where you cloned this repo.

`terrafrom init`

The provider plug-ins download from the Terraform registry into the **.terraform** folder in the directory where we ran the command.

2. Run the following command to deploy the infrastructure to Azure.

#### N.B.

* The default value of the **resource_group_name** variable is unset. Define your own value.
* The default value of the **instance_count** variable is 1. This defines the number of VMs to deploy.

Either update the vars.tf or pass a var as below:

`terraform plan -out -var="resource_group_name=udacity"` - See solution.plan for what this outputs

`terraform apply solution.plan`

### Clean up the environment

`terraform destroy`

### Optional - Deploy a policy

We can create a policy that ensures all indexed resources are tagged. This will help us with organization and tracking, and make it easier to log when things go wrong.

```
az policy definition create --name 'tagging-policy' --display-name 'Add a tag to resources' --description 'Prevents the creation of any resource missing a tag.' --rules 'tagpolicy.rules.json' --mode Indexed
```

```
az policy assignment create --name "tagging-policy" --scope "/subscriptions/<ACCOUNTID>" --policy "tagging-policy"
```

The ACCOUNTID can be found by running the below command:

```
az account show --query "{ subscription_id: id }"
```

az account list and looking up id in the fields.

Check the policy by running `az policy assignment list`


text:
# Hexmatch

(Written to learn javascript)

Matching game using hexagons.

Run from a browser using

http://seryckd.github.io/hexmatch/

repository: seryckd/hexmatch

repo_name: seryckd/hexmatch


text:
---
title: 'Whanganui expats locked down in Berlin '
feature_image:
  description: >-
    Former WHS students, Brodie White and Peter Mangan in Berlin, under an Alan
    Mangan painting of Whanganui.
  image: >-
    https://res.cloudinary.com/whanganuihigh/image/upload/v1585350084/News/The_Have_ex_Brodie_White..Chron_28.3.20.jpg
  credit: Supplied
news_author:
  date: 2020-03-27T22:59:42.910Z
  publication: Whanganui Chronicle
  name: Mike Tweed
image_gallery:
  - description: >-
      Brodie White and Peter Mangan on stage with Sun and the Wolf.  Photo /
      Supplied.
    image: >-
      https://res.cloudinary.com/whanganuihigh/image/upload/v1585350868/News/The_Have_ex_Brodie_White.2..Chron_28.3.20.jpg
show_in_slider: false
date: 2020-03-27T22:59:43.010Z
---
Former Whanganui residents Brodie White and Peter Mangan have lived in Berlin, Germany, for more than a decade, and now find themselves hunkered down together in an apartment in Prenzlauer Berg, on the eastern side of the city.

Late March and April is usually the time Berliners get back out into the streets and parks after long, cold winter months, but this spring the city has remained in hibernation.

Mangan and White moved to Berlin in 2008 with their band The Have, which quickly became Sun and the Wolf on arrival in Europe. Since then, Mangan has become the owner of 8MM Bar, a key part of Berlin's underground music scene. White is a music teacher at the Berlin Cosmopolitan School and bass player for local indie artist Laura Carbone.

Since the outbreak of the Covid-19 pandemic, both of their careers have been put on hold.

"Obviously the bar is shut," Mangan said.

"At the moment it's a matter of getting the right paperwork together to try and get assistance from the German Government and see what funding we're able to get.

"We still need to pay our staff and at the moment the future is really uncertain."

Mangan, son of Whanganui GP Alan Mangan, said he felt "really lucky" that 8MM had a "loyal community of people" around it, and hoped that the bar could continue after the Covid-19 threat had passed.

A GoFundMe page has been set up to help with costs, something Mangan said most of the bars in his area had implemented.

As well as teaching, White has also created a series of children's educational songs and videos under the guise of Skeleton Steve.

He said he'd been teaching guitar online and providing regular video content for the kids in his classroom.

"Obviously schools are shut," White said.

"Every day I share songs and little music lessons online and keep connected with the kids in my classes.

"I'm lucky to have my job at the school, but these are really wonky times all round."

Recording of the upcoming Laura Carbone album, which White has been working on, has also been put on hold.

White said the current Government restrictions in Berlin "didn't seem quite as strict as in New Zealand".

"At the moment you're allowed out in groups of two, or to visit family or a partner, and restaurants are still doing takeaways and stuff.

"I think the laws are constantly changing at the moment.

"It's so hard to enforce as well."

However, Mangan said their dogs Bobby and Zuko were "having the time of their lives".

He said "older people and 20-somethings" seemed to be ignoring the local Government's restrictions on gatherings.

"I've read in the news that some younger people have been having 'corona parties' out at lakes and they've been shut down by the police.

"A lot of older people seem to be ignoring the rules as well, although maybe they just don't have all the latest information available to them."

Both White and Mangan hoped "everyone was doing okay back home".

"Stay inside, and don't you dare have any corona parties," Mangan said.

The 8MM Bar's GoFund Me page is at www.gofundme.com/f/save-8mmbar.

gha_language: Blade


text:
# To-Do-List

In this project, I build a simple HTML list of To Do tasks.This simple web page is built using webpack and served by a webpack dev server.
![image](https://user-images.githubusercontent.com/74506933/130815602-2ccfc959-bf96-4c83-9b79-92925ba57a20.png)

## Built With

- Major languages:
1. ES6/JavaScript
2. HTML
3. CSS

- Technologies used:
5. Git
6. GitHub
7. VS Code

## Live Demo

[Live Demo Link](https://donard97.github.io/To-Do-List/)

### Getting Started

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

Clone the repo with git clone https://github.com/Donard97/To-Do-List

Start the Project `$ npm start` - serve the project in browser.

If you want to test the project run `$ npm test` on terminal .

Install dependencies `$ npm install`.

If you want to build the project `$ npm run build` - this will build the project in /dist folder.

## Authors

👤 **Donard Golaj**

- Github : [@Donard97](https://github.com/Donard97)
- Twitter: [@donardgolaj](https://twitter.com/donardgolaj)
- LinkdIn : [@donard-golaj](https://www.linkedin.com/in/donard-golaj/)

👤 **Rustam Tolipov**

- GitHub: [@githubhandle](https://github.com/Rustamxon7)
- LinkedIn: [LinkedIn](https://www.linkedin.com/in/rustamjon-tolipov-6a831020b)

## 🤝 Contributing
Contributions, issues, and feature requests are welcome!

Feel free to check the issues page.

## Show your support
Give a ⭐ if you like this project!

📝 License
This project is MIT licensed.

gha_language: JavaScript


text:
# Ember-cli-forge

Wraps the [https://github.com/digitalbazaar/forge](forge Javascript encryption library) for use in your Ember app.

Since `forge` does not provide a minified bower package out of the box, this addon provides a script which will build one for you.

## Installation

* `ember install ember-cli-forge`
* `node node_modules/ember-cli-forge/scripts/build-forge.js`

## Usage

See [https://github.com/digitalbazaar/forge](the forge Github page) for documentation on Forge.

This addon exposes the `forge` library as a global variable, so you can simply use it wherever you need it, such as in this contrived example:

```
import Ember from 'ember';

export default Ember.Component.extend({

  actions: {
    encrypt() {
      const val = this.$('#input-text').val();
      const md = forge.md.sha1.create();
      md.update(val, 'utf8');
      ...
    }
  }
});

repository: aaroncraigongithub/ember-cli-forge

repo_name: aaroncraigongithub/ember-cli-forge


text:
[![build](https://github.com/afosto/sendcloud-go/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/afosto/sendcloud-go/actions/workflows/build-and-test.yml)
# sendcloud-go

An API-client for Sendcloud written in Golang.

## Overview [![GoDoc](https://godoc.org/github.com/afosto/sendcloud-go?status.svg)](https://godoc.org/github.com/afosto/sendcloud-go)

This package currently supports:
- parcels
- labels
- methods
- addresses
- integrations

## Install

```
go get github.com/afosto/sendcloud-go
```

## Examples

Some examples on how to use the client are found below.

To initialize the client:
```go
api := client.API{}
api.Init("api_key", "api_secret")
```

To list shipping methods:
```go
methods, err := api.Method.GetMethods()
if err != nil {
    log.Fatal(err)
}

for _, m := range methods {
    log.Print(*m)
}
```
Create a parcel:
```go
params := &sendcloud.ParcelParams{
	Name:             "Sendcloud-GO",
	CompanyName:      "Afosto SaaS BV",
	Street:           "Grondzijl",
	HouseNumber:      "16",
	City:             "Groningen",
	PostalCode:       "9731DG",
	PhoneNumber:      "0507119519",
	EmailAddress<EMAIL_ADDRESS>	CountryCode:      "NL",
	IsLabelRequested: true,
	Method:           8,
	ExternalID:       uuid.New().String(),
}
parcel, err := api.Parcel.New(params)
```

resolve a service point id from postnl,dhl,dpd to a sendcloud service point id
```go
spid, err := api.ServicePoint.GetServicePoint(servicepoint.Matcher{
    SPID:        "NL-972301",
    Carrier:     "dhl",
    Country:     "NL",
    PostalCode:  "9731AR",
    HouseNumber: "41",
    Latitude:    53.226994,
    Longitude:   6.608120,
})

fmt.PrintLn(spid)
```
this service point id can then be placed on an parcel on creation

## Contributing

All contributions / suggestions are welcome. Please raise an issue or submit a PR.

## Thanks

This package was heavily inspired by `stripe-go`.

## Author

This package is developed by [Afosto SaaS BV](https://afosto.com).

## License

MIT.

repository: afosto/sendcloud-go

gha_language: Go

repo_name: afosto/sendcloud-go


text:
# 5/22/20 Friday

## Class Notes

Instance vs. Class Variable. Know the Difference.

To change the instance variable, pass it into the method.

2 ways for methods to talk back:
  - return type

default access = package
```java
public class AlarmClock {
  // class variable
  public static final int MINIMUM = 1;

  // instance variables
  private int snoozeInterval = 5;

  // constructors (ctors)
  public AlarmClock() { }

  public AlarmClock(int snoozeInterval) {
    setSnoozeInterval(snoozeInterval);
  }

  // class methods
  public static final int GET_MINIMUM() {
    return AlarmClock.MINIMUM;
  }

  // instance methods
  int getSnoozeInterval() { // accessor method
    return snoozeInterval;
  }

  void setSnoozeInterval(int minutes) { // mutator method
    snoozeInterval = minutes;
  }
}
```

The same behavior may be invoked in different ways and from different places.
  - Overloading: the same method may be called in different ways, i.e. with different arguments
  - Overriding: the same method in different classes may be invoked with the same arguments

toString() method is commonly used for debugging.


text:
# Graph Property Prediction
## 1. Datasets

### `ogbg-mol`: Prediction of chemical properties of molecules
#### - *Dataset description*
A set of molecular prediction datasets adopted from MoleculeNet [1]. All the molecules are pre-processed using RDKit [2].
Each graph represents a molecule, where nodes are atoms and edges are chemical bonds.
Input node features are 9-dimensional, containing atomic number, chirality, formal charge, etc. Input edge features are 3-dimensional, containing bond type, bond stereo, etc.
For further details, please refer to [code](../utils/features.py).

For encoding these raw input features, we prepare simple modules called `AtomEncoder` and `BondEncoder`. They can be used as follows to embed raw atom and bond features to obtain `atom_emb` and `bond_emb`.
```python
from ogb.graphproppred.mol_encoder import AtomEncoder, BondEncoder
atom_encoder = AtomEncoder(emb_dim = 100)
bond_encoder = BondEncoder(emb_dim = 100)

atom_emb = atom_encoder(x) # x is input atom feature in Pytorch Geometric
edge_emb = bond_encoder(edge_attr) # edge_attr is input edge feature in Pytorch Geometric
```

#### - *List of tasks*
There are diverse kinds of chemical properties of molecules, ranging from biological ones from physical ones.
Successful machine learning models should be able to accurately predict different properties of molecules.
Following MoleculeNet [1], we provide a list of 12 molecule property prediction datasets. The aim is to predict diverse properties of molecules.
Detailed description of each dataset can be found in [1].

*Classification datasets:* `ogbg-mol-bace`, `ogbg-mol-bbbp`, `ogbg-mol-clintox`, `ogbg-mol-muv`, `ogbg-mol-pcba`, `ogbg-mol-sider`, `ogbg-mol-tox21`, `ogbg-mol-toxcast`, `ogbg-mol-hiv`

*Regression datasets:* `ogbg-mol-esol`, `ogbg-mol-freesolv`, `ogbg-mol-lipo`

Each dataset can contain multiple labels/tasks to predict. The goal is to maximize the performance averaged across labels/tasks.

### `ogbg-code`: Prediction of semantic properties of code snippets from their AST graphs
In preparation. Coming soon.

### `ogbg-ppi`: Prediction of species identity from their protein interaction networks
In preparation. Coming soon.

## 2. Modules
### Data loader
We can obtain data-loader for dataset named `d_name` as follows, where we can replace `d_name` with any available datasets (e.g., `"ogbg-mol-tox21"`, `"ogbg-mol-esol"`).

#### - Pytorch Geometric
```python
from ogb.graphproppred.dataset_pyg import PygGraphPropPredDataset
from torch_geometric.data import DataLoader

dataset = PygGraphPropPredDataset(name = d_name)
num_tasks = dataset.num_tasks # obtaining number of prediction tasks in a dataset
splitted_idx = dataset.get_idx_split()

train_loader = DataLoader(dataset[splitted_idx["train"]], batch_size=32, shuffle=True)
valid_loader = DataLoader(dataset[splitted_idx["valid"]], batch_size=32, shuffle=False)
test_loader = DataLoader(dataset[splitted_idx["test"]], batch_size=32, shuffle=False)
```
Note that prediction target is stored in `dataset.y`.

#### - DGL
```python
from ogb.graphproppred.dataset_dgl import DglGraphPropPredDataset, collate_dgl
from torch.utils.data import DataLoader

dataset = DglGraphPropPredDataset(name = d_name)
num_tasks = dataset.num_tasks # obtaining number of prediction tasks in a dataset
splitted_idx = dataset.get_idx_split()

train_loader = DataLoader(dataset[splitted_idx["train"]], batch_size=32, shuffle=True, collate_fn=collate_dgl)
valid_loader = DataLoader(dataset[splitted_idx["valid"]], batch_size=32, shuffle=False, collate_fn=collate_dgl)
test_loader = DataLoader(dataset[splitted_idx["test"]], batch_size=32, shuffle=False, collate_fn=collate_dgl)
```
Note that prediction target of the $i$-th example can be obtained by e.g., `graph, label = dataset[i]`.

### Evaluator
Evaluators are customized for each dataset.
We require users to pass pre-specified format to the evaluator.
First, please learn the input and output format specification of the evaluator as follows.

```python
from ogb.graphproppred import Evaluator

evaluator = Evaluator(name = d_name)
print(evaluator.expected_input_format)
print(evaluator.expected_output_format)
```

Then, you can pass input dictionary (denoted by `input_dict` below) of specified format, and get the performance of your prediction.

```python
# In most cases, input_dict is
# input_dict = {"y_true": y_true, "y_pred": y_pred}
result_dict = evaluator.eval(input_dict)
```

## Reference
[1] Wu, Z., Ramsundar, B., Feinberg, E. N., Gomes, J., Geniesse, C., Pappu, A. S., Leswing, K. & Pande, V. (2018). MoleculeNet: a benchmark for molecular machine learning. Chemical science, 9(2), 513-530.

[2] Landrum, G. (2006). RDKit: Open-source cheminformatics.

repository: mufeili/ogb

repo_name: mufeili/ogb


text:
# data_representation_project
Project Repository for DATA REPRESENTATION module

# Overview
Please note that a live version of the API built for this project, the app that consumes it, and the web interface are available at the below address:
http://chogandatarep.pythonanywhere.com/ticketviewer.html

In order to access the live version of the project you will need to login with the below credentials when the page is first loaded:

USERNAME: admin

PASSWORD: letmein123

This repository contains the following files:

## ticketviewer.html
* This is the homepage for the web interface that interacts with the API.
* It allows a user to create a "help desk ticket" with the following values.
	1. Company name
	2. Description of the ticket
	3. Priority (High, Medium, Low)
* A ticket "Owner" is automatically assigned from a list of 5 possible help desk operators.
* A list of tickets is displayed in a table where they can be updated or deleted.

## dashboard.html
* This page displays a summary table of the ticket Owners and the count of tickets that have been assigned to them.
* There is also the option to generate a pie chart built using D3.js. This shows a breakdown tickets by Priority.

## ticketDAO.py
* This file contains the code used to interact with the database hosted on Pythonanywhere
* The credentials to access the database are stored in the linked "appconfig.py" file.
* The ticketDAO is used to perform the following SQL commands:
	1. insert a new ticket into the tickets table and randomly assign an Owner from one of 5 options by adding an ownerid value (create function)
	2. get all values from the tickets table and get the assigned owners firstname and lastname from the owners table (getAll function)
	3. get a singles tickets values based on the tickets Id and get assigned owners firstname and lastname. (findByID function)
	4. update an individual ticket (update function)
	5. delete an individual ticket (delete function)
	6. get the count of tickets for each priority (getCount function)
	7. get the counts of tickets assigned to each ticket owner (getCountPerOwner function)

## application.py
* This file contains the code for the API
* Each of the SQL commands outlined above has a corresponding route where the information is posted before being displayed on the web interface or applied to the database.

## appconfig.py
File containing credentials for the Pythonanywhere SQL database and the username and password that must be entered to gain access to the API.

## requirements.txt
Contains the list of packages that need to be installed in order for the Flask server to work.

## dump.sql
This contains the SQL commands required to recreate the database used in this project. There should be no need to use this as the database is hosted online as part of the Pythonanywhere app listed above.
However, if there is some issue with the live version of the app, this can be used along with the other files above to recreate the project offline.

gha_language: HTML


text:
# cloudwatch-logs-to-slack-multi

Slack notifications called from CloudWatch Logs subscription filter A Lambda function that does

[for more information in japanese](https://qiita.com/miyaz/items/ed2e0f30d1cc7b96d7c2)

## Overview

CloudWatch Logs' Lambda subscription filter can specify the same function for multiple log groups
Receive log events from multiple log groups with this function and notify Slack
The contents of the notification (icon, user name and channel to be notified) can be changed by saving the settings in the parameter store.

![App Architecture](https://github.com/miyaz/cloudwatch-logs-to-slack-multi/raw/master/cwlogs-to-slack.png)

## Configuration

### Get the Incoming Webhook URL for Slack Notifications

There are two types of Incoming Webhooks

* IncomingWebhook created from the Slack App
  * If you use IncomingWehook here, you can use the notification, username and You can't overwrite the icon. Therefore, you need to create IncomingWebhook for each notification content.
  * Even if you specify it in JSON, which will be described later, it will be ignored.
  * [Setup here](https://api.slack.com/apps)
    * [Instruction is here](https://api.slack.com/messaging/webhooks#getting_started)
* IncomingWebhook created from Custom Integration
  * If you use IncomingWebhook, you can specify individual JSON notifications specified at the time of creation, and if the conditions are met, you can overwrite the notification contents.
  * [Setup here](https://{workspace}.slack.com/apps/manage/custom-integrations)

### Creating the Systems Manager parameter store.

* Parameter Name
  * default value: /lambda/CWLogsToSlack/Configuration
* Type
  * String or SecureString
* Value
  * Text in JSON format as shown below

```
{
  "default": {
    "hook_url":"https://hooks.slack.com/services/HOGEHOGEH/****",
    "channel":"{default destination channel ID}",
    "username":"{slack username}",
    "icon_emoji":"{slack icon_emoji}",
    "color": "{default color(e.g. #D00000)}"
  },
  "rules": [
    {
      "if_prefix": "{Prefix matching string of logGroup:logStreambb}",
      "hook_url":"{Specify when overwriting}",
      "username":"{Specify when overwriting}",
      "channel":"{Specify when overwriting}",
      "color": "{Specify when overwriting}"
    },
        <interchangeable>
        <interchangeable>
        <interchangeable>
  ]
}
```

* If_prefix is a string named {loggroup:logstream} in the log to be processed and If it's true, the default setting is overridden by the individual settings, and the Slack Notified.
* If_prefix and hook_url are required in the rule.

repository: miyaz/cloudwatch-logs-to-slack-multi

repo_name: miyaz/cloudwatch-logs-to-slack-multi


text:
# Display

## Step 1 @unplugged

The BrainPad has an onboard display capable of displaying images, shapes, and text. In this tutorial, we will display several images in a simple animation of a character walking.

![BrainPad buzzer image](../static/images/display.jpg)

## Step 2 @unplugged

Since we're creating an animation, we will want our images to keep playing in a loop, so we'll use the  ``||loops:forever||`` loop already in our project.

```blocks
loops.forever(function () {

})
```
## Step 3 @unplugged

Let's drag in our first image. We can accomplish this by adding a ``||display:show image||`` block. The Butterfly is the default image.

```blocks
forever(function () {
    display.showImage(images.butterfly1)
})
```

## Step 4 @fullscreen

To make our character animate, we have to select the first image frame of the animation. Click on the Butterfly image and change it to the 'walker1' image.

![BrainPad buzzer image](../static/images/selectframe1.jpg)

## Step 5 @fullscreen

Next, let's add the 2nd frame of our animation. Drag in a second ``||display:show image||`` block. Change this one's image to the 'walker2' image.

![BrainPad buzzer image](../static/images/selectframe2.jpg)

## Step 6 @fullscreen

Drag in a third ``||display:show image||`` block. Change this one's image to the 'walker3' image.

When we add the third frame of our animation. You'll notice in the simulator, our character is starting to move more naturally

![BrainPad buzzer image](../static/images/animation.gif)

## Step 7 @fullscreen

Finally, we need to add the last frame of our animation, which when complete loops back to the first image in our code, and completes the animation process. In future tutorials we'll use the BrainPad's inputs to control a simple animation.

```blocks
forever(function () {
    display.showImage(images.walker1)
    display.showImage(images.walker2)
    display.showImage(images.walker3)
    display.showImage(images.walker4)
})
```

repository: digitalpiloten/pxt-brainpad

repo_name: digitalpiloten/pxt-brainpad


text:
# slf4j-jul
Proxy for Slf4j which uses java.util.logging framework. No code change necesary.

Drop the org directory (tree) in your source directory and you are good to go.

Remove any dependencies from slf4j.

In case of errors, you may have to add a method or two to Logger, based on the examples shown.


text:
---
title: "Replacing weatherunderground.com data with...weatherunderground?"
author: 'rubuntu.netlify.com'
date: '2018-05-22'
slug: replacing-weatherundergroundco
link: http://rubuntu.netlify.com/post/2018-05-22-replacing-weatherundergound-com-data-with-weatherundergound-com/
categories:
- bloglink
tags:
  - rubuntunetlifycom
---

Combining these two data sources recreates what weatherunderground.com used to provide. It should be noted that Dark Sky has a slightly different definition of a day for their API, calculating daily averages from 4AM to 4AM, not midnight to midnight. I compared data for previous years and the differences were negligible[... <i class="fas fa-external-link-alt"></i>](http://rubuntu.netlify.com/post/2018-05-22-replacing-weatherundergound-com-data-with-weatherundergound-com/)

repository: mkearney/data-scribers

repo_name: mkearney/data-scribers


text:
# My100DaysOfCode

What I learned and the project I did each day for 100 days in a row.

# Day 1

I learned about Printing, Commenting, Debugging, String Manipulation and applied it to a band name generator at the end.

# Day 2

I learned about different data types and type errors. ALso data type conversion and mathematical operations in python. I applied what I learned today to a tip calculator project.

# Day 3

I learned about control flow and conditional/logical operators. I applied this to a treasure island project.

# Day 4

I learned about the random module in python and the list data structure and combine them both to build a Rock Paper Scissor game.

# Day 5

I learned about for loops and while loops alongside the range function. Using this I built a password generator.

# Day 6

I learned about functions and how they are called. I applied this to a robot maze game called Reborg's World.

# Day 7

I learned about flow charts and how to import python files to your project. Also using what I learned from previous days, I built a hangman game.

# Day 8

I learned more about functions and parameters. Using what I learned I built a caesar cipher program.

# Day 9

I learned about dictionaries and how to nest different structures in them. I applied this to a auction project.

# Day 10

I learned more about function, dictionaries, flags, and recursion. I applied this to a calculator project.

# Day 11

Used everything I learned from the past 10 days to build a Blackjack capstone project.

# Day 12

I learned about global/local scopes in python and constant variables. I applied this to a number guessing game.

# Day 13

I learned about debugging tips and tricks. I applied this to previous coding exercises that had bugs in them.

# Day 14

Using everything I learned so far, I applied it to a Higher/Lower game.

# Day 15

Built a virtual terminal based coffee machine based on the things learned in the previous days.

# Day 16

I learned about object oriented programming and applied it to my coffee machine project from day 15.

# Day 17

Learned more about object oriented programming and applied it to a quiz game.

# Day 18

Learned about the turtle module and applied it to different artistic desgins/shapes.

# Day 19

Learned more about the turtle module and the coordinate system and applied it to a turtle racing game.

# Day 20

Learned more about the turtle module and started to implement the classic snake game.

# Day 21

Learned about inheritance using classes and used it to complete the snake game.

# Day 22

Used what I learned before to create a ping pong game.

# Day 23

Used what I learned about OOP and the turtle module to create a turtle crossing game.

# Day 24

Learned about file handling and file paths. Applied this to a mail merging program.

# Day 25

Learned about the pandas library and csv files. Applied it to a 50 states trivia game.

# Day 26

Learned about list and dictionary comprehension and applied it to a phonetic code word converter.

# Day 27

Learned about the tkinter library in python and applied into to a miles to kilometer converter GUI.


text:
## error
[![Dependency Status][david-dm-image]][david-dm-url] [![Dev Dependency Status][david-dm-dev-image]][david-dm-dev-url] [![NSP Status][nsp-image]][nsp-url]

error middleware for express

this middleware needs to be added as the last middleware in the application; after all “non-error” and “error” middleware. it assumes that if the application got here, an error was sent via next( err ). if response headers have not yet been sent, it will render an error view providing the error message, and if running in a `development` environment, the error object. when rendering the view, it assumes that a view named `error` exists; e.g. `/views/error.hjs`.

```
{{{ message }}}
{{# error.stack }}<pre>{{ error.stack }}</pre>{{/ error.stack }}
```

## setup
```bash
npm install dan-nl/error
```

## use
see [express-http-skeleton][skeleton-url] for an example of use in an application context.

```javascript
var express = require( 'express' );
var app = express();
var error = require( 'error' );

// ... middleware declarations
// ... route declarations

app.use( error );
```

## license
[MIT License][mit-license]

[david-dm-image]: https://david-dm.org/dan-nl/error.svg
[david-dm-url]: https://david-dm.org/dan-nl/error
[david-dm-dev-image]: https://david-dm.org/dan-nl/error/dev-status.svg
[david-dm-dev-url]: https://david-dm.org/dan-nl/error?type=dev
[mit-license]: https://raw.githubusercontent.com/dan-nl/error/master/license.txt
[nsp-image]: https://nodesecurity.io/orgs/githubdan-nl/projects/c7c645b9-4af9-4815-83e2-2fc90f61141d/badge
[nsp-url]: https://nodesecurity.io/orgs/githubdan-nl/projects/c7c645b9-4af9-4815-83e2-2fc90f61141d
[skeleton-url]: https://github.com/dan-nl/express-http-skeleton/blob/master/app.js

repository: dan-nl/error

repo_name: dan-nl/error


text:
## what's the story?

**Plot:**
Detail – Oriented Analyst working both individually and collaboratively across various teams in the Back office, Middle office, and operations, to achieve project goals in the OTC market with a passion for the financial market.
Focuses on Data-driven work and can work efficiently on different computer applications.
Desire to effectively work with diverse cultures in the global team.

### Trade Expense Analyst         Location - Nomura Service India

Improved Reconciliation methodology for invoice processing results into time savings
Daily Validation of Accruals by restructuring the correct source of volume data and rate cards which results in savings for our Department.
Reduced submission timing of Month-End for approval from 3 business days to 2 business days
Expense Variance Analysis and Preparing MIS Reports for senior management reporting daily
Proven team player, taking ownership for own role.

### Market Research Intern        Location - FOODHERO

* Performed market research activities to identify a target market
* Assisted in client onboarding via online and offline channels.
* Provide solutions to client's queries efficiently and in a timely manner.

### Skills

1. Strong control awareness and pay close attention to detail
2. Has the ability to break down problems into parts to resolve them
3. Knowledge of MS Office and SQL, Python
4. Knowledge of business intelligence tools like Power BI, Tableau.

### Skills developed during Work

* polished business communication skills.
* Team Synergy
* writing business E-mails
* Multi-tasking
* Data Reconciliation

### Certifications
* Tableau 2020 A-Z: Hands-On Tableau Training for Data Science
* Introduction To Matlab   - Coursera
* Certified Program on Investment Banking    - Bombay Stock Exchange Limited
* Financial Analyst Course 2019     - Udemy
* Research Analyst Certification Examination    -  National Institute of Securities Markets
* Investment and Portfolio Management   -  NSE.iT Limited

For more details see [GitHub Flavored Markdown](https://guides.github.com/features/mastering-markdown/).


text:
# Tomasulo-Softcore
This is our project submission for a single-core soft CPU running Tomasulo's Algorithm with re-ordering buffers, speculative execution, and memory disambiguation.  This work was prepared for the graduate-level computer architecture course, ECE2162, at the University of Pittsburgh.

# Software Requirements
The project assumes you are running a terminal with Python 3.6+ in the CLI path and execution privileges.  To generate new UML images using the makeUML script, you will need graphviz and pylint3 installed and available in your path.

# Build Instructions
To run the project with a test input, type:
`<python 3> Tomasulo.py test1.txt`
where <python 3> is your python 3 CLI interpreter and test1.txt is a valid input file

# Test Cases
The test cases incrementally test that all instructions are properly supported, that the algorithm is executing correctly, and that the additional features are performing their respective tasks correctly.  The test cases are organized into the testCases/ directory by prefix; "test1.txt", "test1_expected.txt", and "test1_output.txt" designate the input test case file, the hand-derived output expected, and the actual output generated respectively.

To run all tests and enumerate the results, change into the test directory and run the runTests.sh scripts:
`./runTests.sh`

To test individual modules in the src directory, run them directly as scripts:
`<python 3> ROB.py`

# Status
- The project is complete

# Project Requirements
[See here](rubric.md)

# Description of Operation
Our software hierarchy is depicted below in the UML diagram.  To handle the requirement that some functional units are pipelined and others are not, we replicate time-tracking in the subclasses and functional units; cycles are counted and incremented by the top-level Tomasulo class, and for functional units that have time sensitive actions, an advanceTime() function is used to progress by one time unit.

![The class hierarchy UML of the Tomasulo-Softcore](documentation/UML/Hierarchy.png)

# Tasks
## Major Functional Units
- [x] Input Parsing
- [x] ROB class
- [x] RS class
- [x] RAT class
- [x] Integer ALU class
- [x] FP Adder class
- [x] FP Multiplier class
- [x] Instruction Queue class
- [x] Branch Unit class
- [x] Memory Unit class
- [x] Integer Register File
- [x] FP Register File
- [x] Output Generator
- [x] Issue procedure
- [x] Execute procedure
- [x] Memory procedure
- [x] Writeback procedure
- [x] Commit procedure

## Outstanding Test Cases
- [ ] Addressing corner cases test
- [ ] Verify memory disambiguation
- [ ] Complex test case: write patterns to memory
- [ ] Complex test case: sum over floats in memory

repository: mfkiwl/Tomasulo-Softcore

repo_name: mfkiwl/Tomasulo-Softcore


text:
---
layout: post
title: "Docker for Tools"
date: 2017-02-25 20:40
comments: true
categories: [docker]
description: Save time by using Docker containers for your tools instead of installing them (and all of their dependencies).
keywords: docker
---
Something that I've become a strong believer in is using Docker containers to run tools rather than installing them (and all of their dependencies) on your machine.
This is particularly true if you need to have access to multiple versions of a tool with Java being a good example.

What I mean by this is if you ran everything that you typically need as a container (from a Docker image) you should not need to install anything except Docker itself.

Over any period of time I need to use various versions of Java, Python among others.
I used to keep each version locally installed and then go through a process of setting environment variables (such as PATH) to use what I needed at that moment.
Instead, if I use the tools in Docker containers I can run them at will and never need to upgrade/downgrade or generally mess around with my machine.

Along with this is if you contribute any open source software (such as in Github repos) you should also include a Dockerfile that will run them.
Then also consider creating a DockerHub repo that is set to automatically build Docker images for them.
It is particularly important to include descriptive and usage information about your tool.
The DH automatic build will convey the GH README.md info if you do.
This makes it much easier for people to discover, develop trust in and use your tools.
The perfect world is when you provide a Docker image of your tool and someone being able to simply run it without their having to clone, build (with whatever development environment is required), install and then run your tool.

Since most tools require access to local files include in your usage instructions an example of using the Docker volume argument to let your tool operate of local files.
That might be as simple as something similar to the following
`docker run -v $(pwd):/tmp yourtool:1.0`

Note that you should also include version tags for your tools so that if they change the user can still run what has always worked for them.

If you want to see an example of this approach take a look at the following.
I do not claim to be a pro but I can carry a tune.
[https://hub.docker.com/r/dougtoppin/lenticular/](https://hub.docker.com/r/dougtoppin/lenticular/)

You may find that there are some things that you cannot easily do using Docker.
A couple of examples that come to mind are tools that need access to external devices (such as via USB) or use a GUI.
There may not be an existing way to do those with Docker but most everything else is likely to work well.
However, companies and individuals are coming up with ways around those issues with Nvidia being a good example of that.
They provide a Docker compatible driver that interfaces with their GPU.
This allows containers to make use of very high performance found in that sort of hardware.

The main point is think about using and provide support for Docker.
It will only make things easier for you and people that use your stuff.

extension: markdown


text:
# mixins

You can register global mixin component instances when mounting the a component. See [spec.js](spec.js)

See [Vue global mixin docs](https://vuejs.org/v2/guide/mixins.html#Global-Mixin)

repository: cypress-io/cypress

branch_name: refs/heads/develop

repo_name: cypress-io/cypress


text:
---
layout: post
title:  "GSoC Week Five - Mighty Mighty Eagle!"
date:   2016-06-04 11:39:55 +0530
tags: gsoc
---
A month has elapsed since I started my GSoC project. It's been a great learning experience and I've learnt several aspects about Mozilla's Testing infrastructure.
This week I saw the new [Angry Birds Movie](https://en.wikipedia.org/wiki/The_Angry_Birds_Movie), and I can't seem to get Peter Dinklage's [Mighty Eagle](https://www.youtube.com/watch?v=hxBsM1QOZbE) song out of my head. So I had very little choice while I chose my theme.

![eagle]({{ site.url }}/assets/eagle.jpg)

Getting back to work, this is how it's been last week :-

## MozCI Tools / Pulse Actions

Now that I'm done with the first two parts of my GSoC project, I need to prepare MozCI Tools to receive the modified Pulse messages and parse them appropriately.
This is seeming difficult since I don't have the required TaskCluster scopes to publish to Treeherder. Armen might need to make a [Rapid Risk Assessment](https://wiki.mozilla.org/Security/Risk_management/Rapid_Risk_Assessment) before I can make any progress.

In the meantime, I've done some preparatory work in [this](https://github.com/mozilla/mozilla_ci_tools/pull/480) Pull Request to download the latest full-tasks-graph.json file from the TC Index. I've also started work on parsing the new Pulse Messages in [this](https://github.com/mozilla/pulse_actions/pull/82) Pull Request.

Armen has assigned two bugs to me, related to MozCI. In the [first one](https://bugzilla.mozilla.org/show_bug.cgi?id=1274483) I need to handle nightly builders in MozCI. I also need to check some special properties of the Android nightly builds. In the [second one](https://bugzilla.mozilla.org/show_bug.cgi?id=1276914) I need to remove the MozCIError which is raised when a non existing builder is passed.

## Photometric Redshifts

I've started a [project](https://github.com/martiansideofthemoon/Photometric-Redshifts) where I will estimate redshifts of galaxies in the [SDSS database](www.sdss.org) using machine learning. I've implemented the [kNN regression](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm#k-NN_regression) algorithm and got a fairly decent result. I hope to move to a Neural Network soon.

![knn]({{ site.url }}/assets/knn_regression.png)

## Other News

We are starting the third [Quarter of Contribution](https://wiki.mozilla.org/Auto-tools/New_Contributor/Quarter_of_Contribution/Summer_2016) on Monday, 4th June. [nihal111](https://github.com/nihal111) and [arpan98](https://github.com/arpan98) will be helping [jgraham](https://github.com/jgraham) and me hack [wptview](https://github.com/mozilla/wptview). Congratulations!

## Coming Up!

This week I hope to address the issues pointed out on my Treeherder [pull request](https://github.com/mozilla/treeherder/pull/1490). I also hope to solve the two bugs assigned to me Armen. If the security issue is resolved, I will proceed with scheduling TC jobs.


text:
API Doc is an API Rest test technology, it works as a CRUD, where you can access the documentation from anywhere, I was inspired by applications like Swagger, Postman and Insonmia to create it.

### Mobile - (Cordova or PWA)

|              Main Menu              |              List Api               |                Paths                |
| :---------------------------------: | :---------------------------------: | :---------------------------------: |
| ![](documentation/docs/image/1.png) | ![](documentation/docs/image/2.png) | ![](documentation/docs/image/3.png) |

### Client Electron for Desktop

![Destkop Electron](documentation/docs/image/electronDesktop.png)

> Attention: Cordova and Electron Builds ask for the address of a Remote API, they work only as customers, while the PWA version does not make this requirement, as it runs in the same container as the API - for more, see in docs ["Cordova And Electron Docs"](https://joaomede.github.io/Api-Doc/pages/CordovaAndElectron.html)

## Get Started

### See Full [Documentation](https://joaomede.github.io/Api-Doc)

### Need to get started fast? go docker [Docker Compose Settings](https://joaomede.github.io/Api-Doc/pages/Docker.html)

[![dockeri.co](https://dockeri.co/image/joaomede/apidoc)](https://hub.docker.com/r/joaomede/apidoc)

### Features

- [x] Dockerized? Yes!
- [x] Login and Register, Change Password
- [x] Team System
- [x] Api Documentation "private and public"
- [x] Client Electron for Windows, Mac And Linux Dist
- [x] PWA/SPA Works
- [ ] SSR Builder
- [x] Cordova Android
- [ ] Cordova iOS
- [x] Test Request
- [x] Register Responses and Codes Definitions
- [x] Methods Accept: Post, Get, Delete, Put
- [x] Accept: Headers, Params Path and Body
- [x] Accept: Query Params
- [ ] Accept: DataForm, in Dev

## License

[MIT](LICENSE)

repository: joaomede/Api-Doc

gha_language: Vue

repo_name: joaomede/Api-Doc


text:
---
title: inventory_contributor_name_types
---
## Source:

Module: mod-inventory-storage

Interface: /contributor-name-types

## Attributes:

| Property Name              | Property Type   | Property Description                                                                               |
|:---------------------------|:----------------|:---------------------------------------------------------------------------------------------------|
| id                         | string          |                                                                                |
| name                       | string          | label for the type of contributor name                                                             |
| ordering                   | string          | used for ordering of contributor name types in displays, i.e. in select lists                      |
| metadata                   | object          | Metadata about creation and changes to records, provided by the server (client should not provide) |
| metadata/createdDate       | string          | Date and time when the record was created                                                          |
| metadata/createdByUserId   | string          | ID of the user who created the record (when available)                                             |
| metadata/createdByUsername | string          | Username of the user who created the record (when available)                                       |
| metadata/updatedDate       | string          | Date and time when the record was last updated                                                     |
| metadata/updatedByUserId   | string          | ID of the user who last updated the record (when available)                                        |
| metadata/updatedByUsername | string          | Username of the user who last updated the record (when available)                                  |

repository: amzoss/schema-parser

repo_name: amzoss/schema-parser


text:
# KSysGuard AMDGPU Sensor

This is a small tool to graph AMD GPU values using KSysGuard. It Implements the KSysGuard Protocol
separately if anyone wants to reuse it.

## How To Use

Clone this repo and then use the Go toolchain to build

    go build .

You can then either run it as a daemon (listens on localhost:2635) or run it as a command.

In KSysGuard go to

    File -> Monitor Remote Machine

Enter a value for host (e.g. <IP_ADDRESS>), Choose "`Custom Command`" and
enter `/the/full/path/ksysguard-amdgpu`. Hit `OK` and you should now see the some extra fields to
graph in your Sensor Browser!

Note: You might want to `File -> New Tab` to see the sensor browser

repository: bluntelk/ksysguard-amdgpu

repo_name: bluntelk/ksysguard-amdgpu