Service discovery, operational concerns and future trends
Setup Your Box
To Build, Test, Run and Deploy Microservices using Docker
Setup workshop VM Install Prerequisites from USB drive
Install VirtualBox-5.0.14 from installers directory
Install vagrant-1.8.1 from installers directory
If you are running Windows:
Install Git-2.7.1 from installers directory.
Use default locations suggested by installers.
Restart your machine when requested by installers.
Copy content of usb-stick to your computer
Open up the slides
Important* - If using Windows, unzip from Git Bash
Open file index.html found in slides directory on your computer
You should see these instructions in your browser
and be able to copy and paste commands if needed
Run the Workshop VM
Start up the workshop VM
from workshop-dist/box directory on your machine
$ cd workshop-dist/box
workshop-dist/box$ vagrant box add workshop workshop.box
workshop-dist/box$ vagrant up
workshop-dist/box$ vagrant ssh
If you are using Windows run Git Bash
$ cd 'workshop-dist\box\'
workshop-dist\box$ vagrant box add workshop workshop.box
workshop-dist\box$ vagrant up
workshop-dist\box$ vagrant ssh
Hands-on Sessions Overview
Introduction of your playground and the rules
The Playground Overview
Glossary
$ vagrant up
Command to run on your machine from workshop-dist/box directory to start up workshop VM
$ vagrant ssh
Command to run on your machine from workshop-dist/box directory to log into workshop vm. This should be called after starting the vm. All consequent commands run on the workshop VM
vagrant@workshop:~$
Prompt displayed when running commands on microservices VM
/home/vagrant/topics/{state}/{topic_name}
Topic builder scripts for start/finish state on workshop VM
~$ cd /home/vagrant/topics/{state}/{topic_name}
{topic_name}$ ./up.sh
Command to configure a topic in the start or finish state on workshop VM
/home/vagrant/workspace/...
Source code repositories on the workshop VM
{dir-on-your-machine}/my-workspace/...
Source code repositories on your machine. This directory is synced with workshop VM
Git repositories on your VM
Some exercises will require modifying files in your local Git workspaces
On your VM these will be under:
/home/vagrant/workspace/
On your computer these will be under:
{dir-on-your-machine}/my-workspace/
Always commit and push changes from your VM (not from your computer)
Example of making changes in the VM terminal:
echo "Hello world" > my-new-file.txt
git status # See new/modified files
git add my-new-file.txt
git commit -m "Some useful message about the change"
git push # Submit change to the remote repository (hosted your VM)
When you push changes, Go-CD will detect the change a kick off a build (it periodically polls the git repositories for changes)
Getting Started
Check your workshop VM is configured properly
Run the getting started topic
Log into workshop VM
If you are using Windows run Git Bash
workshop-dist/box$ vagrant ssh
Run the getting_started topic script
vagrant@workshop:~$ cd ~/topics/start/getting_started
Intro to the Monolith and Continuous Delivery with Go-CD
Workshop Journey
Why are we here? What are we going to do?
Our journey today...
Monolithic shop app
Deploy shop app
Extract Review Service
Extract Catalogue Service
Consumer Driven Contracts
Module 1 - Overview
This module uses the shop-app in it's monolithic form, i.e. no external services used. You will have to build, test, package and deploy the shop-app via a delivery pipeline.
Once deployed, you can access the application on your host machine at:
http://localhost:8090
You will learn about:
Continuous Delivery (CD) pipelines
Typical stages in a CD pipeline
Go-CD as a tool for implementing a delivery pipeline
Become familiar with the Musik shop app
Build artifacts and tagging them with a build number
Continuous Delivery
"...teams continuously deliver new versions of software to production by decreasing the cycle time
between an idea and usable software through the automation of the entire delivery system:
build, deployment, test, and release." (DZone Refcardz: Continuous Delivery)
Continuous Delivery (CD) takes Agile and Continuous Integration further by enabling frequent, automated, repeatable, low-risk delivery into Production ("the last mile")
The CD pipeline is a key construct used to automate the delivery process
Software is always in a releaseable state - each commit is a release candidate until proven otherwise
Demonstates real progress - no delayed integrations; visibility
Exposes bottlenecks and other inefficiencies
Provides rapid feedback at all stages of the delivery process
Fits well into distributed team structures
Continuous Delivery: Pipeline
Image credit: Continous Delivery (book), Jez Humble and David Farley
Built a basic CD pipeline to build, test, package and deploy the "Musik Shop" app
Reviewed basic Continous Delivery concepts
Previewed application deployment to Docker
Module 1 - Tips and Advice
Use CD Pipelines to automate your build process and provide feedback on production readiness of software
Model your build process as a series of stages for improved feedback
Provide scripts for building, testing, packaging and deploying your apps:
Store these with your app code
Call them from your CI/CD tool
Build artifacts once and use them in downstream stages / pipelines
Always tag your build artifacts with a build number
Extend your CD pipeline to automate deployment into your environments
Monolithic apps can be easy to build and deploy as they have less moving parts
Module 2
Meet our first microservice and Docker
Our journey today...
Monolithic shop app
Deploy shop app
Extract Review Service
Extract Catalogue Service
Consumer Driven Contracts
Module 2 - Overview
In this module, we extract the album review functionality from the monolithic shop-app into a separate service called the review service. You will be provided with the Go-CD build and deploy pipelines for both the shop-app and review service.
Once deployed, you can access the application on your host machine at:
http://localhost:8090
You will learn about:
Introduction to Microservices
Introduction to Docker
Basics of working with Docker from the command-line
Become familiar with the review service
Exploring review service API documentation
Meet our first microservice: Review
Our first extracted service is called review service
Change the code so that it retrieves the star ratings via the review service
Challenge - Part 2/3
Update monolithic shop app to use review service
Edit the deploy.sh script to link the shop-app container to the review container:
vagrant@workshop:shop-app$ nano scripts/deploy.sh
Search for the TODO comment
Edit the line starting with docker run to look like this:
docker run ... --link review:review ...
Challenge - Part 3/3
Update monolithic shop app to use review service
Commit and push your changes to trigger a new build
Wait until your builds have completed and are green
Deploy your review service from the ReviewService-Deploy pipeline (*)
Then deploy your shop-app from the ShopApp-Deploy pipeline
Can you see the star ratings in the shop-app?
Refresh the app in your browser: http://localhost:8090/
(*) Due to limitations of Docker Links, there is some ordering imposed on the deployment of our app and services. This will be addressed in Module 4.
Docker Overview
"Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications. Consisting of Docker Engine, a portable, lightweight runtime and packaging tool, and Docker Hub" (docker.com/whatisdocker)
Which ports are forwarded to the host for the review service?
View logs for one of the running containers
Open a terminal inside a running container. Which processed are running?
Module 2 - Wrap-up
Extracted album star ratings functionality into the review service
Quick intro to Microservices and some characteristics
Quick overview of Docker
Examined Docker setup on your computer
Examined packaging services in Docker images with Maven
Examined running containers using Docker images
Explored Docker from the command-line
Built a Docker image from a Dockerfile
Created a simple time server using the tiny busybox image
Module 2 - Tips and Advice
It's ok to start with a monolith then extract services once you understand your business domain and bounded contexts
Try to keep your Docker images small (e.g. base them on busybox, alpine, or debian)
Don't use Docker containers like full blown VMs - Run a single process in each Docker container
Use Docker links to communicate between containers (on the same host)
Log to STDOUT, STDERR not to files
Configure apps / services via ENV variables or use an external config store (e.g. etcd, consul)
Use OS service scripts to keep your containers running and to start them on boot (e.g. Upstart, Systemd)
Module 3
Our second microservice and Consumer-driven Contracts
Module 3 - Overview
In this module, we extract the album catalogue functionality from the shop-app into a separate service called the catalogue service. You will be provided with the Go-CD build and deploy pipelines for the shop-app,
review and catalogue services. We will also run through a DDD exercise.
Once deployed, you can access the application on your host machine at:
http://localhost:8090
You will learn about:
Domain Driven Design
Structuring build and deploy pipelines to support autonomous teams and service deployment
Consumer-driven contracts
Our journey today...
Monolithic shop app
Deploy shop app
Extract Review Service
Extract Catalogue Service
Consumer Driven Contracts
Meet our second microservice: Catalogue
Our second extracted service is called Catalogue service
(*) Due to limitations of Docker Links, there is some ordering imposed on the deployment of our app and services. This will be addressed in Module 4.
Our journey today...
Monolithic shop app
Deploy shop app
Extract Review Service
Extract Catalogue Service
Consumer Driven Contracts
Consumer-driven Contracts
Each consumer captures expectations of a provider in a separate contract
Each consumer generates this contract during the test stage
Consumer-driven Contracts
Each consumer captures expectations of a provider in a separate contract
Each consumer generates this contract during the test stage
Provider must comply to every contract and runs a verification test against all generated contracts
Consumer-driven Contracts
Consumer-driven Contracts
Each consumer captures expectations of a provider in a separate contract
Each consumer generates this contract during the test stage
Provider must comply to every contract and runs a verification test against all generated contracts
We are using pact library to help us generate and verify these contracts
Benefits:
No complex, slow and brittle integration tests
Helps the teams to stay more agile
Easier to make changes and also identify any potential consumer impacts
Faster reponses and reduces likelihood of flakey tests
CDC - Characteristics
[CDC] imbues providers with insight into their consumer obligations, and focuses service evolution around the delivery of the key business functionality demanded by consumers. (MartinFowler.com)
Characteristics:
Allows services to evolve independently of each other and supports independent releasing of services
Increase service independence by sharing contracts, not types
Allows consumers to express and assert their expectations of a service/provider contract
Allows testing against a single producer in isolation leading to faster, more reliable tests than end-to-end tests
CDCs are a codified set of discussions about what a service API should look like
Failures are a trigger point to have conversations about how the API should evolve
Registrator is a service registry bridge for Docker
"Registrator automatically register/deregisters services for Docker containers based on published ports and metadata from the container environment" [1]
Registrator helps us automate registering our services without needing to explicitly add registration code to talk to the Consul REST API
A real-world production environment does not usually consist of a single host running the application and services
We want to:
Reduce single points of failure in the system
Increase availability of our applications and services
Horizontally scale our applications and services
We can do this by:
Running multiple instances of each application/service behind load-balancers
Distributing our instances across multiple hosts
Production Setup
Multi-Host Deployment with Docker Swarm
Our shop-app and services run inside Docker containers
How can we deploy our Docker containers across multiple hosts?
The Docker engine running on a host can only manage containers on it's host
We need some kind of Docker-aware clustering system
Docker Swarm is one possible solution to this problem
It provides native clustering for Docker
It abstracts a pool of Docker hosts into a single, virtual host
It presents the standard Docker API - meaning you can use existing tools, like the docker command-line client, to manage the cluster
It is a "batteries included" solution but allows for swapping in more powerful backends
Docker Swarm
Docker Swarm
Docker Swarm - Binpack Strategy
Docker Swarm - Spread Strategy
Docker Swarm - Deploy with constraints
Hierarchical Correlation IDs
Monitoring System
Look at Prometheus as an example for a monitoring and metrics solution
Prometheus uses a pull model over HTTP to collect metrics* in a special format
You can either directly instrument your services using one of the provided client libraries or use one of the metrics exporters
When running multiple containers we do not want to couple the monitoring server to each container's health/metrics endpoint
Consul supports checking health status on services - our services are already known to Consul (via Registrator)
We can make use of the Consul Exporter to get our service health checks out of Consul and into Prometheus
(*) A push model is supported via an intermediary gateway
Consul Server Healthchecks
Prometheus Alerts
Prometheus Ad-hoc Metric Graphs
Operations Dashboards
Once we start to have many sources of useful information (e.g. monitoring, metrics, graphs, etc) it becomes difficult to consume
A visual dashboard provides a summary of important information from different sources at a glance
What is the most useful information we should know about right now?
Candidates:
Application health and status - are our apps and services up?
Error counts and trends
Resource usage and trends - can we identify problems before they occur?
Overall available capacity - disk, CPU, memory, network bandwidth
Number of deploys, deployed versions, response times, etc.
Business metrics - signups, purchases, click-throughs, etc.
Tips and Advice
When scaling container-based services it becomes impractical to map each instance of a container statically to specific hosts - use service discovery
Use Docker Swarm as your cluster manager with the default scheduling backend - other backends are only needed for very large-scale operations
Use a private discovery backend like Consul - do not use the publicly hosted discovery service
Use load-balancers - like HAProxy - to scale your services
Use load-balancer endpoints for service discovery not individual service instances
Ensure your services provide healthcheck endpoints so that load-balancers can stop routing traffic to unhealthy instances
Ensure your load-balancers are not a single-point of failure
Tips and Advice cont.
Log aggregation, monitoring and other operational concerns should be planned into development work early on - not bolted on as an afterthought
Standardise on healthcheck, metrics and other endpoints for your services to simplify monitoring configuration
Standardise on log structure and formats to help in log aggregation and analysis tasks
Implement semantic monitoring by running key user journeys in Production with synthetic transactions
Build custom dashboards for specific audiences that summarise the most important information they care about
Make dashboards visible, e.g. display on a big TV screen or project onto the wall
Get development and operations people working together
First Steps
Congratulations! You've made it to the end :)
What now?
Go back over the workshop material on your own: scripts, CD pipeline configuration, the source code for the app, services, etc.
Read through the linked references (in the slides and READMEs)
Start small...
Extract or build a small, low-risk service first
Dockerise your service
Start with a single Docker host and automate everything needed to build it from scratch
Setup your own basic CD pipeline to deploy your service to production
Continous Delivery
Products, not Projects
Next Steps...
Successful adoption of Microservices depends on some prerequisites like rapid server provisioning, basic monitoring, automated deployment pipelines, and embracing a DevOps culture
Advice
Get log aggregation and monitoring in place early
Only look at a cluster management once when you understand Docker and it's edge-cases properly
You probably won't need advanced schedulers like Mesos and Kubernetes for your Enterprise apps just yet - use Docker Swarm with it's "batteries included" to start with
WARNING: Docker is still evolving and the ecosystem is immature
Avoid being locked into a technology which is too intrusive or too opinionated
If it's the wrong choice it's hard to back out; let the dust settle, see which front-runners emerge
Future Trends
Continuous Delivery
Continuous Delivery becoming the normal way of doing business
Long-lived, cross-functional, product-aligned teams who own the entire software lifecycle
DevOps culture
Microservices
Use of lightweight SOA within an organisation - moving away from heavyweight ESBs
Teams share business functions via well-defined service-oriented APIs - not shared libraries
Decentralised governance: Teams can use the right tool for the job rather than being forced to use some Enterprise-wide standard
Cloud uptake continues to grow and adoption becomes the norm
Changing architectures: Horizontal scaling, event-driven, microservices, design for failure, optimise for MTTR (mean-time to recover) over MTBF (mean-time between failures)
SDN (Software-Defined Networking) and NFV (Network Function Virtualisation)
Storage virtualisation and services
Future Trends
Other related trends
Shift to commodity hardware and software-based functions over specialised hardware appliances
Open-source is the leading edge: Commercially-funded open-source model with paid versions packaged extra features or premium support
Immutable infrastructure: baked VM images (AMIs), container images, rebuild - not update
Lightweight and atomically updatable OSes for microservice/container use-cases


Bode Story
Bode was born in a community south of the Atlantic.  Loved by his parents , liked by his peers , Bode was an admiration all over SogonaLand.
Before his birth , there was Unaba , the most liked person in SogonaLand but his story ended in a mystery and culminated with a bitter ending
Bode's parent did not want Unaba to Happen to Bode


Cyclone Idai like disaster: Zim govt warns of heavy rains, flooding this week
Zimbabwe could experience a disaster worse than Cyclone Idai which claimed at least 300 lives and hundreds more still reported missing, the government has warned.
In a statement issued today, the government said people should stay away from danger due to impending floods, strong winds, hail storm and lightning as heavy rains are predicted in many parts of the country this week .
See attached document below:


Make a memorable experience. Let your traveling be in a way that will exceed your expectations.
 You’re tired of life stuck in the hamster wheel, and want to reclaim a little bit of freedom, ease and joy. A chance to just slip into a hammock undisturbed at sunset with an ice cold drink and a slow sway to the tunes of your favourite song. And the opportunity to tell more enriching stories and have something to laugh about in the years to come. Maybe it’s something more you want to escape to – a road trip in Australia or across the USA, a trek to Machu Picchu, teaching English in Asia, or a gap year that turns into three
I’m sure we can all agree that travel allows us to escape the everyday formalities, giving us a sense of ownership over our lives. It offers an exotic spark of adventure and discovery that our day-to-day lives seem to gloss over.


Analysis - Correlate¶
This module is for correlation analysis between multiple masts. The typical format is to give the method the site and reference MetMast or RefMast objects. The method then returns a DataFrame of results. Those results can then be applied with a separate method.
For example, correlations typically require two lines of text. One for running the actual correlation between masts and one for applying that correlation to synthesize missing data:
1 2 | corr_results_10min = an.analysis.correlate.masts_10_minute_by_direction(ref_mast, site_mast)
syn_10min = an.analysis.correlate.apply_10min_results_by_direction(ref_mast, site_mast, corr_results_10min)
|
-
analysis.correlate.
apply_10min_results_by_direction
(ref_mast, site_mast, corr_results, ref_ws_col=None, ref_dir_col=None, site_ws_col=None, splice=True)[source]¶ Applies the slopes and offsets from a 10-minute correaltion, binned by direction, between two met masts.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- corr_results: DataFrame
- slope, offset, R2, uncert, points for each direction sector
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- ref_dir_col: string, default None (primary vane assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- splice: Boolean, default True
- Returns site data where available and gap-fills any missing periods between the site mast and the reference mast’s measurement period. Otherwise, returns purely sythesized data without taking into account the measured wind speeds.
Returns: - out: time series DataFrame
- predicted wind speeds at the site
-
analysis.correlate.
apply_daily_results_by_month
(ref_mast, site_mast, corr_results, ref_ws_col=None, site_ws_col=None, splice=True)[source]¶ Applies the slopes and offsets from a daily correaltion, binned by month, between two met masts. If the reference or site masts don’t have daily time series the method resamples to daily frequency, requiring 70% data coverage within each day to be a valid day.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- corr_results: DataFrame
- slope, offset, R2, uncert, points for each direction sector
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- ref_dir_col: string, default None (primary vane assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- splice: Boolean, default True
- Returns site data where available and gap-fills any missing periods between the site mast and the reference mast’s measurement period. Otherwise, returns purely sythesized data without taking into account the measured wind speeds.
Returns: - out: time series DataFrame
- predicted wind speeds at the site
-
analysis.correlate.
apply_daily_results_by_month_to_mast_data
(mast_data, corr_results, ref_ws_col='ref', site_ws_col='site', splice=True)[source]¶ Applies the slopes and offsets from a daily correaltion, binned by month, to a DataFrame of wind speed data.
Parameters: - mast_data: DataFrame
- timeseries of wind speed data
- corr_results: DataFrame
- slope, offset, R2, uncert, points for each month
- ref_ws_col: string, default ‘ref’
- Reference anemometer data to use. Extracted from mast_data DataFrame.
- site_ws_col: string, default ‘site’
- Site anemometer data to use. Extracted from mast_data DataFrame
- splice: Boolean, default True
- Returns site data where available and gap-fills any missing periods between the site mast and the reference mast’s measurement period. Otherwise, returns purely sythesized data without taking into account the measured wind speeds.
Returns: - out: time series DataFrame
- predicted wind speeds at the site
-
analysis.correlate.
calculate_EDF_uncertainty
(data, ref_ws_col='ref', site_ws_col='site')[source]¶ Calculate the EDF estimated correlation uncertainty between two wind speed columns. Assumes a correlation forced through the origin
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref_ws_col and site_ws_col
- ref_ws_col: string, default ‘ref’
- Reference anemometer data column to use.
- site_ws_col: string, default ‘site’
- Site anemometer data column to use.
-
analysis.correlate.
calculate_IEC_uncertainty
(data, ref_ws_col='ref', site_ws_col='site')[source]¶ Calculate the IEC correlation uncertainty between two wind speed columns
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref_ws_col and site_ws_col
- ref_ws_col: string, default ‘ref’
- Reference anemometer data column to use.
- site_ws_col: string, default ‘site’
- Site anemometer data column to use.
-
analysis.correlate.
calculate_R2
(data, ref_ws_col='ref', site_ws_col='site')[source]¶ Return a single R2 between two wind speed columns
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref_ws_col and site_ws_col
- ref_ws_col: string, default ‘ref’
- Reference anemometer data column to use.
- site_ws_col: string, default ‘site’
- Site anemometer data column to use.
-
analysis.correlate.
masts_10_minute
(ref_mast, site_mast, ref_ws_col=None, site_ws_col=None, method='ODR', force_through_origin=False)[source]¶ Calculate the slope and offset between two met masts.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
masts_10_minute_by_direction
(ref_mast, site_mast, ref_ws_col=None, ref_dir_col=None, site_ws_col=None, site_dir_col=None, method='ODR', force_through_origin=False, dir_sectors=16)[source]¶ Calculate the slope and offset, binned by direction, between two met masts.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- ref_dir_col: string, default None (primary wind vane assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_dir_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- dir_sectors: int, default 16
- Number of equally spaced direction sectors
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
masts_daily
(ref_mast, site_mast, ref_ws_col=None, site_ws_col=None, method='ODR', force_through_origin=False, minimum_recovery_rate=0.7)[source]¶ Calculate the slope and offset for daily data between two met masts.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
- minimum_recovery_rate: float, default 0.7
- Minimum allowable recovery rate until resampled data are excluded. For example, by defalt, when resampling 10-minute data to daily averages you would need at least 101 valid records to have a valid daily average.
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
masts_daily_by_month
(ref_mast, site_mast, ref_ws_col=None, site_ws_col=None, method='ODR', force_through_origin=False, minimum_recovery_rate=0.7)[source]¶ Calculate the slope and offset for daily data, binned by month, between two met masts.
Parameters: - ref_mast: MetMast
- MetMast object
- site_mast: MetMast
- MetMast object
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
- minimum_recovery_rate: float, default 0.7
- Minimum allowable recovery rate until resampled data are excluded. For example, by defalt, when resampling 10-minute data to daily averages you would need at least 101 valid records to have a valid daily average.
Returns: - out: DataFrame
- slope, offset, R2, uncert, points for each month
-
analysis.correlate.
return_correlation_data_from_masts
(ref_mast, site_mast)[source]¶ Return a DataFrame of reference and site data for correlations. Will be extracted from each MetMast object using the primary anemometers and wind vanes.
Parameters: - ref_mast: MetMast
- Anemoi MetMast object
- site_mast: MetMast
- Anemoi MetMast object
Returns: out: DataFrame with columns ref, site, and dir
-
analysis.correlate.
valid_ws_correlation_data
(data, ref_ws_col='ref', site_ws_col='site')[source]¶ Perform checks on wind speed correlation data.
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref_ws_col and site_ws_col
- ref_ws_col: string, default ‘ref’
- Reference anemometer data column to use.
- site_ws_col: string, default ‘site’
- Site anemometer data column to use.
-
analysis.correlate.
ws_correlation_binned_by_direction
(data, ref_ws_col='ref', site_ws_col='site', ref_dir_col='dir', dir_sectors=16, method='ODR', force_through_origin=False)[source]¶ Calculate the slope and offset, binned by direction, between two wind speed columns.
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- ref_dir_col: string, default None (primary wind vane assumed)
- Reference wind vane data to use. Extracted from MetMast.data
- dir_sectors: int, default 16
- Number of equally spaced direction sectors
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
ws_correlation_binned_by_month
(data, ref_ws_col='ref', site_ws_col='site', method='ODR', force_through_origin=False)[source]¶ Calculate the slope and offset, binned by month, between two wind speed columns.
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
ws_correlation_least_squares_model
(data, ref_ws_col='ref', site_ws_col='site', force_through_origin=False)[source]¶ Calculate the slope and offset between two wind speed columns using ordinary least squares regression.
https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.lstsq.html
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
ws_correlation_method
(data, ref_ws_col='ref', site_ws_col='site', method='ODR', force_through_origin=False)[source]¶ Calculate the slope and offset, for a given correlation method, between two wind speed columns.
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- method: string, default ‘ODR’
Correlation method to use.
- Orthoginal distance regression: ‘ODR’
- Ordinary least squares: ‘OLS’
- Robust linear models: ‘RLM’
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
ws_correlation_orthoginal_distance_model
(data, ref_ws_col='ref', site_ws_col='site', force_through_origin=False)[source]¶ Calculate the slope and offset between two wind speed columns using orthoganal distance regression.
https://docs.scipy.org/doc/scipy-0.18.1/reference/odr.html
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points
-
analysis.correlate.
ws_correlation_robust_linear_model
(data, ref_ws_col='ref', site_ws_col='site', force_through_origin=False)[source]¶ Calculate the slope and offset between two wind speed columns using robust linear model.
http://www.statsmodels.org/dev/rlm.html
Parameters: - data: DataFrame
- DataFrame with wind speed columns ref and site, and direction data dir
- ref_ws_col: string, default None (primary anemometer assumed)
- Reference anemometer data to use. Extracted from MetMast.data
- site_ws_col: string, default None (primary anemometer assumed)
- Site anemometer data to use. Extracted from MetMast.data
- force_through_origin: boolean, default False
- Force the correlation through the origin (offset equal to zero)
Returns: - out: DataFrame
- slope, offset, R2, uncert, points


Status Reported On
01/01/1000
Print this page
Project Details
Title:
M&O?
Manager:
Lead:
Created On:
Target Date:
Accomplishments this Week
Next Week Goals
Project Stakeholders
SDLC Phase-based Status
Phase
Started?
Status
Intake Planning & Impact Analysis
Requirements
Design
Build & Test
Implementation (Delivery & PO)
Final Client Acceptance
Closing & Sustainment
Issues & Mitigation
Issues
Mitigation
Lessons Learnt
History - Status Reported Trend
Date Reported
Overall
Action
SDLC Phase Statuses
Intake
Reqmt
Design
Build
Rollout
Accept
Sust
© 2020. All Rights Reserved. California State Controller's Office. ISD Division.
This portal is for authorized personnel only. For access request please contact ISD Customer Service


In the meantime, read about the value of Interfaith Dialogue and why it matters to you.
Here's the religious sentiment of your entire friends list. Each dot represents a person you are friends with. Hover over a dot for more info.
Share Results on Facebook
Your browser does not support CSS animations.


Grade Predictor
Home
(current)
How to use the grade predictor
Course name
Credit
Submit
Clear list
Your Items
Sno
Course
Credit
Action
1
Math
4
Delete
Check


Ping-Pong
Home
Ping-Pong
Read Me
Ping-Pong will count up to your number from 1, with the following exceptions:
Numbers divisible by 3 are replaced with "ping"
Numbers divisible by 5 are replaced with "pong"
Numbers divisible by 15 are replaced with "ping-pong"
Play! Ping-Pong


New Folders
  New Files
  Bin
Folder
songs
photos
videos
movies
Q_papers
Folder
Files
F1.pdf
F2.txt
F3.docx
F4.pdf
Name
Owner
Last Modified
File size
F1.pdf
me
Nov 28 2015
2MB
F2.txt
me
Jan 18 2016
36KB
F3.docx
me
March 14 2016
40KB
F4.pdf
me
April 20 2016
3MB
New Folder
New File
Open
Rename
Delete
Rename
Delete
×
New Folder
×
New File
×
Change profile picture
×
Rename
Please enter a new name for this file
×
New Folder
×
New File


This tool turns a curl command into crystal (1.0.0) code using http/client
. Currently, it knows the following options: -d
/--data
, -H
/--header
, -I
/--head
, -u
/--user
, -k
/--insecure
, --url
, and -X
/--request
.
There's probably bugs; please contribute on GitHub. Based on curl-to-go, also based on curl-to-ruby
Simple · Basic Auth · JSON · Complex JSON · Form Data


The Email component allows us to send and receive emails without user interaction.
Example - Example
function OnStart()
{
email = app.CreateEmail<EMAIL_ADDRESS>"MyPass" );
email.SetSMTP( "smtp.gmail.com", 465 );
email.SetOnStatus( email_OnStatus );
app.ShowProgress( "Sending..." );
email.Send( "My Subjewct", "My Content"<EMAIL_ADDRESS><EMAIL_ADDRESS>);
}
function email_OnStatus( status )
{
app.HideProgress();
app.ShowPopup( status );
}
Methods
The following methods are available on the Email object:
string
number: integer
number: integer: 993 or
995
number: integer: 465 or
578 or
587
string: path to file or folder ( “/absolute/...” or “relative/...” )
string: “email”
string: “password”
string: “email address”
object: {
from,
to,
cc,
subject,
body }
eml.GetType
Returns the control class name.
eml.Receive
Start receiving emails from a given folder.
eml.Send
Send an email to someone.
eml.SetIMAP
Set IMAP or POP3 settings for receiving messages.
eml.SetOnMessage
Define a callback function which is called when a message is received.
eml.SetOnStatus
Define a callback function which is called when a status changed.
eml.SetSMTP
Set SMTP settings for sending messages.


Keras.NET
Keras.NET is a high-level neural networks API, written in C# with Python Binding and capable of running on top of TensorFlow, CNTK, or Theano. It was developed with a focus on enabling fast experimentation. Being able to go from idea to result with the least possible delay is key to doing good research.
Use Keras if you need a deep learning library that:
Allows for easy and fast prototyping (through user friendliness, modularity, and extensibility). Supports both convolutional networks and recurrent networks, as well as combinations of the two. Runs seamlessly on CPU and GPU.
Keras.NET is using:
Prerequisite
- Python 3.6, Link: https://www.python.org/downloads/
- Install keras, numpy and one of the backend (Tensorflow/CNTK/Theano). Please see on how to configure: https://keras.io/backend/
Nuget
Install from nuget: https://www.nuget.org/packages/Keras.NET
Install-Package Keras.NET
dotnet add package Keras.NET
Example with XOR sample
//Load train data
NDarray x = np.array(new float[,] { { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 } });
NDarray y = np.array(new float[] { 0, 1, 1, 0 });
//Build sequential model
var model = new Sequential();
model.Add(new Dense(32, activation: "relu", input_shape: new Shape(2)));
model.Add(new Dense(64, activation: "relu"));
model.Add(new Dense(1, activation: "sigmoid"));
//Compile and train
model.Compile(optimizer:"sgd", loss:"binary_crossentropy", metrics: new string[] { "accuracy" });
model.Fit(x, y, batch_size: 2, epochs: 1000, verbose: 1);
//Save model and weights
string json = model.ToJson();
File.WriteAllText("model.json", json);
model.SaveWeight("model.h5");
//Load model and weight
var loaded_model = Sequential.ModelFromJson(File.ReadAllText("model.json"));
loaded_model.LoadWeight("model.h5");
Output:
MNIST CNN Example
Python example taken from: https://keras.io/examples/mnist_cnn/
int batch_size = 128;
int num_classes = 10;
int epochs = 12;
// input image dimensions
int img_rows = 28, img_cols = 28;
Shape input_shape = null;
// the data, split between train and test sets
var ((x_train, y_train), (x_test, y_test)) = MNIST.LoadData();
if(K.ImageDataFormat() == "channels_first")
{
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols);
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols);
input_shape = (1, img_rows, img_cols);
}
else
{
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1);
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1);
input_shape = (img_rows, img_cols, 1);
}
x_train = x_train.astype(np.float32);
x_test = x_test.astype(np.float32);
x_train /= 255;
x_test /= 255;
Console.WriteLine("x_train shape: " + x_train.shape);
Console.WriteLine(x_train.shape[0] + " train samples");
Console.WriteLine(x_test.shape[0] + " test samples");
// convert class vectors to binary class matrices
y_train = Utils.ToCategorical(y_train, num_classes);
y_test = Utils.ToCategorical(y_test, num_classes);
// Build CNN model
var model = new Sequential();
model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(),
activation: "relu",
input_shape: input_shape));
model.Add(new Conv2D(64, (3, 3).ToTuple(), activation: "relu"));
model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple()));
model.Add(new Dropout(0.25));
model.Add(new Flatten());
model.Add(new Dense(128, activation: "relu"));
model.Add(new Dropout(0.5));
model.Add(new Dense(num_classes, activation: "softmax"));
model.Compile(loss: "categorical_crossentropy",
optimizer: new Adadelta(), metrics: new string[] { "accuracy" });
model.Fit(x_train, y_train,
batch_size: batch_size,
epochs: epochs,
verbose: 1,
validation_data: new NDarray[] { x_test, y_test });
var score = model.Evaluate(x_test, y_test, verbose: 0);
Console.WriteLine("Test loss:", score[0]);
Console.WriteLine("Test accuracy:", score[1]);
Output
Reached 98% accuracy within 3 epoches.


Eth2phone allows anyone send and receive ether with minimal knowledge of cryptocurrency transaction mechanics.
Got a friend, who’s not owning ether, yet?  All he needs is enter the receive tabs and follow simple steps, he’d even create the wallet instantly straight from there.
We put 2 things in priority here : simplicity and safety.
We’ve written the smart contract that allows you to send ether, verifying the receiver via SMS. In case of mistake, it allows you to cancel the transaction until it was received (has «awaiting receiving» status).
The smart contract is built in a way that ether can be transferred only by the verification server with receiver’s address signed by a “verification private key”. Receiver only sends the address signed by verification private key to server, but not the verification private key. This means that not at any point the server has access to verification private key and to move ether to an illegal address.
Receiver doesn’t need to have a wallet, it could be generated on-the-fly, and funds will be transferred to it. The system is as simple as it was possible - just select the action - send/receive and follow couple simple steps.


Overpass endpoint:
[out:json] [timeout:25] ; ( node ["aerialway"] (51.648,10.647,51.668,10.685); way ["aerialway"] (51.648,10.647,51.668,10.685); relation ["aerialway"] (51.648,10.647,51.668,10.685); ); out tags;


The root element for a query file is
graph-query
. The
graph-query
tag must appear
immediately after the document type declaration. The query XML file
ends with the closing </graph-query>
tag.
The graph-query
specifies the
name of the query in the required
name
attribute. Queries must
include a query-body
element, and
may optionally include a description and layout information for the
Query Editor.
<graph-query>
Attributes
name |
required | The name of the query |
Children
description |
zero or one | String describing the query |
query-body |
exactly one | Specifies the graph pattern to be matched |
editor-data |
zero or one | Specifies layout information for the query editor |
Content Model
(description?, query-body)
Example
<graph-query name="1d-clusters"> <description>Finds 1d-clusters</description> <query-body>see query-body
</query-body> <editor-data>see editor-data
</editor-data> </graph-query>


During week 9 of phase 0, we were tasked with sprucing up our personal blogs to make them look more professional. This was a great opportunity to refresh my understanding of CSS and update my bag of tricks.
While pairing last week, my partner introduced me to overflow: scroll as a means of adding a scrollbar to a div. This really added a touch of "modernism" to my blog, which originally looked like something out of the mid-90s. I also played around with border radius and linear gradients to add more stylistic flourishes.
One of the most challenging aspects of revamping my blog was applying changes to past posts. Significant updates had to be made to the html and the stylesheet. This was a lesson to be more mindful of the future when writing code. The code should be adaptive to change in order to minimize back tracking. As I made updates, I was more careful and thorough when creating divs, classes, and ids.
While my blog has improved, I plan on dedicating next Sunday to adding more updates and improving my personal website. I especially want to experiment with DOM-manipulation. Despite painpoints around updating past blog posts, it was great to see how I've improved in html and CSS.
Previous | Next


Three-wheeled motorcycle makes for a stable ride
In Europe, the sight of a scooter with two front wheels is not that odd. There are quite a number of manufacturers who have adopted that design and one of them is Yamaha.
by Brian CheyneThey produced the 125cc Tricity that was available in South Africa not so long ago. Now Yamaha has gone and stuck two front wheels on the MT-09 and the result is the radical Yamaha Niken.
The bike has the same three-cylinder 847cc engine from the MT-09, but I only was asked once what size the engine is.
Everywhere I stopped with the Niken, a crowd soon gathered and I had to field questions about the complicated front-end set-up. Everyone wanted to know how the Niken handles and rides with it. The answer is simple – just like a regular motorcycle!
Looking at the front, the Niken has four fork legs, two on each side. The leading forks are inert and add rigidity and stability to the front.
The trailing set handles the damping. At the top there are two parallelogram arms, attached to the two steering heads.
ALSO READ: A Himalayan turned towards the Moroccan sands
This means that the wheels lean in unison, but they work independently to absorb bumps. The front wheels are only 15″ units and each one has a 298mm disc. The rear of the Niken gets a wider tyre and larger disc at the back to make up for the smaller front discs.
Sitting on the Niken, you are fully aware of the large shroud over the front suspension. At first it felt ungainly, but when I realised that the Niken is only about 4cm wider than the MT-09, my trepidation about lanesplitting disappeared.
My mind was also playing tricks on me. I wanted the Niken to feel different when riding and yet I was only aware of the extra wheel at low speeds. The engine pulls strongly and the quickshifter worked a treat, provided I was very aggressive with the throttle.
Where the Niken really shines is with stability. You would think that the two front wheels will make the bike planted through corners, and you would be absolutely right. But that is not all.
Riding in a serious crosswind, I was surprised at how stable the Niken is.
ALSO READ: Fuel consumption tested in a race with a difference
It is fitted with cruise control and will therefore make a very good sports tourer. I will just fit a taller windscreen, as the standard one is not very effective.
Say what you want about the Niken, but it is an amazing motorcycle that you have to ride to appreciate and understand.


Kayako TicketStatus object.
All objects interacting with Kayako REST API should extend this class and
define:
* Kayako controller
* XML element name holding object's data in REST response
Methods
Default constructor.
__construct(array $data)
Inherited
| inherited_from |
\kyObjectBase::__construct() |
Parameters
$data
array
Object data from XML response converted into array.
Returns API field value.
__get(string $api_field_name) : mixed
Inherited
Returns API field value based on API field name used by Kayako.
Parameters
$api_field_name
string
API field name.
Returns
mixed
Sets API field value.
__set(string $api_field_name, mixed $value) : mixed
Inherited
Sets API field value based on API field name used by Kayako.
Parameters
$api_field_name
string
API field name.
$value
mixed
API field value.
Returns
mixed
Returns object description with it's type and identifier.
__toString() : string
Inherited
Calls toString() method to get the object description.
| inherited_from |
\kyObjectBase::__toString() |
Returns
string
Should build the array of object data for creating or updating the object.
buildData(bool $create) : array
Inherited
Values must be set in format accepted by REST API.
| inherited_from |
\kyObjectBase::buildData() |
Parameters
$create
bool
Indicates if the result will be used to create (true) or update (false) an object.
Returns
array
Checks wheter this object has all required fields set.
checkRequiredAPIFields(bool $create, bool $throw_exception) : string[] | bool
Inherited
| inherited_from |
\kyObjectBase::checkRequiredAPIFields() |
Parameters
$create
bool
True when object will be created. False when object will be updated.
$throw_exception
bool
True to throw an exception on missing fields. False to return list of missing fields or true when there are none.
Exceptions
\kyException |
When there are missing field values and $throw_exception is true. |
Returns
string[]
bool
List of missing API fields or true when there are none.
Creates an object on the server and refreshes its local data.
create() : \kyObjectBase
Inherited
| inherited_from |
\kyObjectBase::create() |
Exceptions
Returns
Creates new object.
createNew()
Inherited
Compatible with method chaining.
| inherited_from |
\kyObjectBase::createNew() |
Deletes the object on the server.
delete()
Inherited
| inherited_from |
\kyObjectBase::delete() |
Fetches the object from server.
get(int | array $id) : \kyObjectBase
Inherited
| inherited_from |
\kyObjectBase::get() |
Parameters
$id
int
array
Object identifier or list of identifiers (ex. ticket identifier and ticket post identifier when fetching TicketPost).
Returns
Returns array of API fields.
getAPIFields() : string[]
Inherited
Format of returned array:
array(
'' => Field description. (getter: , setter: ),
...repeat...
)
| inherited_from |
\kyObjectBase::getAPIFields() |
Returns
string[]
Fetches objects from server.
getAll(array $search_parameters) : \kyResultSet
Inherited
| inherited_from |
\kyObjectBase::getAll() |
Parameters
$search_parameters
array
Optional. Additional search parameters.
Returns
Returns list of available filter methods for use in result sets with objects of this type.
getAvailableFilterMethods(bool $filter_names_only) : array
Inherited
Optionaly you can return get method names used to filter objects.
| inherited_from |
\kyObjectBase::getAvailableFilterMethods() |
Parameters
$filter_names_only
bool
True (default) to return array('filterByXXX', 'filterByYYY', ...). False to return array('filterByXXX' => 'getXXX', 'filterByYYY' => 'YYY', ...).
Returns
array
Returns list of available order methods for use in result sets with objects of this type.
getAvailableOrderMethods(bool $order_names_only) : array
Inherited
Optionaly you can return get method names used to order objects.
| inherited_from |
\kyObjectBase::getAvailableOrderMethods() |
Parameters
$order_names_only
bool
True (default) to return array('orderByXXX', 'orderByYYY', ...). False to return array('orderByXXX' => 'getXXX', 'orderByYYY' => 'YYY', ...).
Returns
array
Returns object controller.
getController() : string
Inherited
| inherited_from |
\kyObjectBase::getController() |
Returns
string
Returns linked department.
getDepartment(bool $reload) : \kyDepartment
If a ticket status is linked to a department, it will be visible only under the linked department.
Result is cached until the end of script.
Parameters
$reload
bool
True to reload data from server. False to use the cached value (if present).
Returns
Returns linked department identifier.
getDepartmentId() : int
If a ticket status is linked to a department, it will be visible only under the linked department.
Returns
int
Returns whether ticket count for this status is displayed in the filter ticket tree.
getDisplayCount() : bool
Returns path to icon displayed in GUI for this ticket status.
getDisplayIcon() : string
Returns ticket status display order.
getDisplayOrder() : int
Should return object identifier or complete list of identifiers as needed by API to identify the object (ex.
getId(bool $complete) : int | array
ticket identifier and ticket post identifier in case of TicketPost).
Parameters
$complete
bool
True to return complete list of identifiers as needed by API to identify the object.
Returns
int
array
Returns whether tickets with this status are marked as resolved/closed.
getMarkAsResolved() : bool
Returns list of required API fields for objects of this class.
getRequiredAPIFields(bool $create) : string[]
Inherited
| inherited_from |
\kyObjectBase::getRequiredAPIFields() |
Parameters
$create
bool
True when object will be created. False when object will be updated.
Returns
string[]
Returns whether Kayako will automatically clear the due time for a ticket when the ticket status changes to this status.
getResetDueTime() : bool
Returns list of identifiers of staff groups which can change ticket status to this status.
getStaffGroupIds() : int[]
| filterBy |
name=StaffGroupId |
| orderBy |
name=StaffGroupId |
Returns
int[]
Returns list of staff groups which can change ticket status to this status.
getStaffGroups(bool $reload) : \kyResultSet
Result is cached until the end of script.
Parameters
$reload
bool
True to reload data from server. False to use the cached value (if present).
Returns
Returns whether a ticket status can be changed to this status only by the selected staff teams.
getStaffVisibilityCustom() : bool
Returns background color associated with this ticket status in GUI.
getStatusBackgroundColor() : string
This color is used for the "General Tab Bar" in Kayako GUI when viewing the ticket.
Returns
string
Returns font color associated with this ticket status in GUI.
getStatusColor() : string
Returns ticket status title.
getTitle() : string
If whether whenever a ticket is changed to this ticket status a survey email will be dispatched to the user asking for rating and comments.
getTriggerSurvey() : bool
Returns type of this ticket status.
getType() : string
| see |
\global\kyTicketStatus::TYPE |
| filterBy |
|
| orderBy |
|
Returns
string
Returns whether this ticket status is visible under specified department.
isAvailableInDepartment(\kyDepartment | int $department) : bool
Returns whether the object is new and not yet saved on the server.
isNew() : bool
Inherited
| inherited_from |
\kyObjectBase::isNew() |
Returns
bool
Returns whether this object is read only.
isReadOnly() : bool
Inherited
| inherited_from |
\kyObjectBase::isReadOnly() |
Returns
bool
Returns whether this ticket status can be set by specified staff group.
isVisibleToStaffGroup(\kyStaffGroup | int $staff_group) : bool
Refreshes the object data from server.
refresh() : \kyObjectBase
Inherited
| inherited_from |
\kyObjectBase::refresh() |
Exceptions
Returns
Saves (creates or updates) the object to the server.
save() : \kyObjectBase
Inherited
| inherited_from |
\kyObjectBase::save() |
Returns
Sets whether this object is read only.
setReadOnly(bool $read_only) : bool
Inherited
| inherited_from |
\kyObjectBase::setReadOnly() |
Parameters
$read_only
bool
Read only flag.
Returns
bool
Should return short (one line) description of the object (it's title, name, etc.).
toString() : string
Updates the object on the server and refreshes its local data.
update() : \kyObjectBase
Inherited
| inherited_from |
\kyObjectBase::update() |
Exceptions
Returns
Adds boolean field to object data array only if its value is non-empty.
buildDataBool(array $data, string $field_name, mixed $field_value)
Inherited
| inherited_from |
\kyObjectBase::buildDataBool() |
Parameters
$data
array
Data used to create or update the object.
$field_name
string
Field name.
$field_value
mixed
Field value.
Adds array field to object data array only if its value is proper array and is non-empty.
buildDataList(array $data, string $field_name, mixed $field_value)
Inherited
| inherited_from |
\kyObjectBase::buildDataList() |
Parameters
$data
array
Data used to create or update the object.
$field_name
string
Field name.
$field_value
mixed
Field value.
Adds numeric field to object data array only if its value is proper number.
buildDataNumeric(array $data, string $field_name, mixed $field_value)
Inherited
| inherited_from |
\kyObjectBase::buildDataNumeric() |
Parameters
$data
array
Data used to create or update the object.
$field_name
string
Field name.
$field_value
mixed
Field value.
Adds string field to object data array only if its value is non-empty.
buildDataString(array $data, string $field_name, mixed $field_value)
Inherited
| inherited_from |
\kyObjectBase::buildDataString() |
Parameters
$data
array
Data used to create or update the object.
$field_name
string
Field name.
$field_value
mixed
Field value.
Returns REST client.
getRESTClient() : \kyRESTClientInterface
Inherited
| inherited_from |
\kyObjectBase::getRESTClient() |
Returns
Should use passed data to fill object properties.
parseData(array $data)
Parameters
$data
array
Object data from XML response.
Builds API fields list.
initAPIFieldsAccessors()
Inherited
Scans protected and private properties of called class, searches for
| apiField |
[name=field name]{0,1} [alias=field name alias]* [accessor=setter/getter name]{0,1} [getter=getter name]{0,1} [setter=setter name]{0,1} [required_create=true if field if required when creating object]{0,1} [required_update=true if field if required when udpating object]{0,1} [required=true if field if required when creating or updating object]{0,1}
and builds API field list with property name, description, setter and getter method names, and required flags. |
| see |
\global\kyObjectBase::$_api_fields |
| inherited_from |
\kyObjectBase::initAPIFieldsAccessors() |
Properties
Cache for available filter methods.
$_filter_methods : string[]
Inherited
Format:
array(
'' => array(
'' => '',
...repeat for every filtering enabled method...
),
...repeat for every object class...
)
| inherited_from |
\kyObjectBase::$$_filter_methods |
Cache for available order methods.
$_order_methods : string[]
Inherited
Format:
array(
'' => array(
'' => '',
...repeat for every ordering enabled method...
),
...repeat for every object class...
)
| inherited_from |
\kyObjectBase::$$_order_methods |
Default Kayako controller used to operate on this objects.
$controller : string
Override in descending classes.
Linked department identifier.
$department_id : int
If a ticket status is linked to a department, it will be visible only under the linked department.
If ticket count for this status is displayed in the filter ticket tree.
$display_count : bool
Path to icon displayed in GUI for this ticket status.
$display_icon : string
Ticket status display order.
$display_order : int
Ticket status identifier.
$id : int
If tickets with this status are marked as resolved/closed.
$mark_as_resolved : bool
Indicates the name of object element in XML response.
$object_xml_name : string
Override in descending classes.
Controls if the object can be created/updated/deleted.
$read_only : bool
Override in descending classes.
If enabled, Kayako will automatically clear the due time for a ticket when the ticket status changes to this status.
$reset_due_time : bool
Identifiers of staff groups which can change ticket status to this status.
$staff_group_ids : int[]
| apiField |
name=staffgroupid |
If enabled, a ticket status can be changed to this status only by the selected staff teams.
$staff_visibility_custom : bool
| see |
\global\kyTicketStatus::$staff_group_ids |
| apiField |
|
Background color associated with this ticket status in GUI.
$status_bg_color : string
This color is used for the "General Tab Bar" in Kayako GUI when viewing the ticket.
Font color associated with this ticket status in GUI.
$status_color : string
Ticket status title.
$title : string
If enabled, whenever a ticket is changed to this ticket status a survey email will be dispatched to the user asking for rating and comments.
$trigger_survey : bool
Type of ticket status.
$type : string
| see |
\global\kyTicketStatus::TYPE |
| apiField |
|
Cache for API fields.
$_api_fields : array
Inherited
Format:
array(
'' => array(
'' => array(
'property' => '',
'description' => '',
'getter' => '',
'setter' => '',
'required_create' => ,
'required_update' =>
),
...repeat for every class api field...
),
...repeat for every object class...
)
| inherited_from |
\kyObjectBase::$$_api_fields |
Staff groups which can change ticket status to this status.
$staff_groups : \kyStaffGroup[]
Constants
Data key for storing files to send as multipart/form-data.
FILES_DATA_NAME : string
Inherited
| inherited_from |
\kyObjectBase::FILES_DATA_NAME |
TYPE_PRIVATE
TYPE_PRIVATE


Data Table - Montana Details
Toggle column display on and off.  Search for words to filter the list. Sort by columns. Press the (+) / (-) icons to toggle the display of details. Note that Data Table - Montana does not have detail information in child rows.
| # | title | given name(s) | surname | media | literary form | OCLC Number | |
|---|---|---|---|---|---|---|---|
| # | title | given name(s) | surname | media | literary form | OCLC Number |
This page uses the DataTables jQuery library for the display of its table.[1] This HTML5 page with its "data-*" attributes is uneditable by Amaya. Use a text editor or an HTML5 capable editor. The page was validated with a file upload at https://validator.w3.org/ and found to have "No errors or warnings to show".
This short list of media related to Montana[2] provides real data in a table. Real data better shows this use of the DataTables library.
This table lists media about or somehow related to Montana. This list is just a sample. Many more books, movies, e-publications, music, audio-books and webpages could be added.
Reference
- ^ See DataTables at https://datatables.net/ and https://github.com/DataTables retrieved on 2016 07 19
This use of DataTables was created from the datatables.net site's Download builder using these settings: Main libraries, JQuery - No JQuery, Styling - DataTables, DataTables - DataTables, Extensions - all set to Do not include, Packaging options, Minification - Minify, Concatenate - Single file, CDN - Local files. - ^ The list is my own creation. Titles, names and other information were checked by looking at Library of Congress Online Catalog MARC records. See https://catalog.loc.gov/vwebv/searchKeyword. The OCLC Numbers were found at http://www.worldcat.org. Typically the edition choosen is the 1st edition or the newest edition as seemed appropriate for the particular publication. Retrieved during July and August 2016.


Artiste Name: Adekunle Gold
Latest Releases: Something Different
Recent Albums: About 30
Ratings:
Most Liked Collection: GOLD
Listen
Artiste Name: SIA
Latest Releases:Chandelier
Recent Albums: This is Acting
Ratings:
Most Liked Collection: 1000 Forms of Fear
Listen
Artiste Name: Ed Sheeran
Latest Releases: I Don't Care
Recent Albums: No.6
Ratings:
Most Liked Collection: X


Class OctagonBar, that holds all the nessesary information for OctagonBar and it's details therefore we can use in the interface.
More...
#include <octagon_bar.h>
|
| struct | Properties |
| | Struct with material specific properties TODO:Check if this can be moved to the base class. More...
|
| |
|
|
std::ostream & | operator<< (std::ostream &os, const OctagonBar &obj) |
| | Shift operator overload for class Aluminium, this will print all the nessesery informations.
|
| |
Class OctagonBar, that holds all the nessesary information for OctagonBar and it's details therefore we can use in the interface.
◆ Type
| Enumerator |
|---|
| OctagonBar | This grade is commercially pure aluminum. It is soft and ductile and has excellent workability, making it ideal for applications with difficult forming. It can be welded using any method, but it is non heat-treatable. It has an excellent resistance to corrosion and is commonly used in the chemical and food processing industries.
|
◆ OctagonBar()
| MassCalculator::Shapes::OctagonBar::OctagonBar |
( |
double |
side, |
|
|
double |
length |
|
) |
| |
◆ getDiagonal()
| double MassCalculator::Shapes::OctagonBar::getDiagonal |
( |
void |
| ) |
const |
Get the Radius object.
- Returns
- const double Radius of the OctagonBar
◆ getLength()
| double MassCalculator::Shapes::OctagonBar::getLength |
( |
void |
| ) |
const |
Get the Length object.
- Returns
- const double Length of the OctagonBar
◆ getSide()
| double MassCalculator::Shapes::OctagonBar::getSide |
( |
void |
| ) |
const |
Get the Side object.
- Returns
- const double Side of the OctagonBar
◆ getSurfaceArea()
| double MassCalculator::Shapes::OctagonBar::getSurfaceArea |
( |
void |
| ) |
const |
Get the Surface Area object.
- Returns
- double Surface Are of the OctagonBar
◆ getType()
| std::string MassCalculator::Shapes::OctagonBar::getType |
( |
void |
| ) |
const |
Get the Surface Area object.
- Returns
- double Surface Are of the OctagonBar
◆ getVolume()
| double MassCalculator::Shapes::OctagonBar::getVolume |
( |
void |
| ) |
const |
Get the Volume object.
- Returns
- double Volume of the OctagonBar
◆ setSize()
| bool MassCalculator::Shapes::OctagonBar::setSize |
( |
double |
side, |
|
|
double |
length |
|
) |
| |
Set the Size object.
- Parameters
-
- Returns
- true If setting the size is successful
-
false If setting the size fails
The documentation for this class was generated from the following files:
- /home/runner/work/masscalculator.github.io/masscalculator.github.io/MassCalculator/masscalculator-core/libraries/masscalculator-core/include/masscalculator/masscalculator-core/shapes/octagon_bar.h
- /home/runner/work/masscalculator.github.io/masscalculator.github.io/MassCalculator/masscalculator-core/libraries/masscalculator-core/src/shapes/octagon_bar.cc


Applies to
- PCI DSS Requirement 12.5
- PCI DSS Requirement 12.5.1
- PCI DSS Requirement 12.5.2
- PCI DSS Requirement 12.5.3
- PCI DSS Requirement 12.5.4
- PCI DSS Requirement 12.5.5
What to Do
Assign information security responsibilities.
How
Designate an information security team. Assign responsibility for information security to the Chief Information Security Officer or another qualified member of management. Assign the following responsibilities to formal staff positions in the company or
to contractors:
- Managing policies and procedures
- Monitoring alerts, reviewing logs, and notifying the appropriate staff
- Managing incident response procedures
- Managing user accounts
- Managing data access control


This page gives access to the Javadoc documentation of the Net2Plan classes needed for writing Net2Plan algorithms and reports.


The function controls the clan hall door.
When the door open, anyone can enter -- even those who are not members of the clan. For security purposes, you should keep the door closed as much as possible.
If you wish to expel non-clan members, use the Expel Outsider menu.


William Shakespeare's Romeo And Juliet (1996) A film review by Scott Renshaw Copyright 1996 Scott Renshaw
Grade: B+ // Worth a Ticket
(20th Century Fox)
Director: Baz Luhrmann. Screenplay: Craig Pearce and Baz Luhrmann. Director of Photography: Donald McAlpine. Producers: Gabriella Martinelli, Baz Luhrmann. Starring: Leonardo DiCaprio, Claire Danes, John Leguizamo, Harold Perrineau, Dash Mihok, Pete Postlethwaite, Miriam Margoyles.
MPAA Rating: PG-13 (adult themes, violence) Running Time: 121 minutes.
WILLIAM SHAKESPEARE'S ROMEO AND JULIET is an exercise in such sheer audacity that you will probably want either to stand up and applaud director Baz Luhrmann or smack him in the head. I mean, using jump cuts, fast-motion, American accents and rock music, then calling his film _WILLIAM SHAKESPEARE'S_ ROMEO AND JULIET? Setting the story against 20th century gang violence, as though WEST SIDE STORY never had existed? You need two pairs of pants to hold cajones that big, but this is one of those rare cases where nothing succeeds like excess. Al Pacino tried to make Shakespeare "relevant" with a hyped-up lecture in LOOKING FOR RICHARD; Luhrmann's glorious and gaudy ROMEO AND JULIET does it right. It is a work full of energy, humor and surprisingly gentle romance.
The story, of course, is based around two warring clans, the Montagues and the Capulets, set in sunny, flashy, modern-day Verona Beach. The men loyal to Ted Montague (Brian Dennehy) include his son Romeo (Leonardo DiCaprio), Romeo's cousin Benvolio (Dash Mihok) and Romeo's friend Mercutio (Harold Perrineau); the partisans of Fulgencio Capulet (Paul Sorvino) are led by his nephew Tybalt (John Leguizamo). In an act of daring and defiance, Romeo and his cohorts crash a party at the Capulet mansion, and there Romeo spies a vision in white named Juliet (Claire Danes). Unfortunately, Juliet is Capulet's daughter, a circumstance which forces the lovers to woo and wed in secret. Meanwhile, the war continues unabated, and a tragic death forces Romeo to flee from Verona and from a love destined to be written in the stars.
For half an hour or so, you might wonder whether Luhrmann and his co-writer Craig Pearce have decided to turn the love story into an afterthought. The film's first image is a television screen, featuring a news anchorwoman introducing the events; Luhrmann then bursts directly into the conflict between the Montagues and the Capulets with a face-off at a gas station. That face-off is staged with frenzied editing more akin to Robert Rodriguez than Franco Zeffirelli, and there is scarcely time for a breath before we barrel into the costume ball, where Mercutio (played with dazzle and fire by SMOKE's Harold Perrineau) prances in drag to disco. In between there is a broadly comic scene in which Juliet's mother (Diane Venora) is made by camera trickery to move like a darting insect as she dresses for the party. It is a visual blitzkrieg Luhrmann launches, played against a soundtrack which surges from the up-tempo rock of Garbage to Mozart to a ballad by Des'ree before DiCaprio and Danes ever share a scene.
Once they do meet, however, the wait seems quite worthwhile. The scene in which they first see each other, staring through a fish tank, is beautiful in its quiet observation, as is Juliet's dance with suitor Paris (CLUELESS's Paul Rudd) while she is unable to take her eyes off Romeo. Their connection registers immediately, one of the most effective and convincing portrayals of love at first sight I have seen in years, and Danes and DiCaprio share a sweet but powerful chemistry. They may be the best male and female actors of their generation, respectively, and they give themselves both to the characters and to the language so completely that they seem to be discovering the 400-year-old text for the first time.
Luhrmann directs their moments together as idyllic interludes in a world of chaos and violence, but he also gives them a fair amount of sexual double-entendre, and anyone with more than a nodding acquaintance with the Bard knows that Lurhmann didn't create those bawdy references himself to appeal to the teenagers in the audience. He is interested in those young viewers, however, and that is what makes his vision of WILLIAM SHAKESPEARE'S ROMEO AND JULIET so faithful even in its iconoclasm. Shakespeare was a writer for every social stratum of his time, and ROMEO AND JULIET is an action-filled teen romance which also retains the tragic force of the play. Through it all, Luhrmann also manages to make Shakespeare's words an integral part of his film. The rapid, colloquial deliver of those words occasionally overwhelms them, and Luhrmann doesn't always know when to turn down the adrenaline. What he has done is to take dynamic lead performances by Claire Danes and Leonardo DiCaprio and guide them through a telling of WILLIAM SHAKESPEARE'S ROMEO AND JULIET which makes the poetry and thematic depth of the play resonate in 1996. Luhrmann took his own stab at looking for Shakespeare, and may end up showing him to an entirely new audience.
On the Renshaw scale of 0 to 10 star-cross'd lovers: 8.
Receive Scott Renshaw's reviews directly via email from Marquee! Visit http://www.marquee.com/marquee-mailinglists.html for details. ******** Visit Scott Renshaw's MoviePage http://www-leland.stanford.edu/~srenshaw
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews