Class: Rack::BodyProxy
| Relationships & Source Files | |
| Extension / Inclusion / Inheritance Descendants | |
|
Subclasses:
|
|
| Inherits: | Object |
| Defined in: | lib/rack/body_proxy.rb |
Overview
Proxy for response bodies allowing calling a block when the response body is closed (after the response has been fully sent to the client).
Class Method Summary
-
.new(body, &block) ⇒ BodyProxy
constructor
Set the response body to wrap, and the block to call when the response has been fully sent.
Instance Attribute Summary
-
#closed? ⇒ Boolean
readonly
Whether the proxy is closed.
Instance Method Summary
-
#close
If not already closed, close the wrapped body and then call the block the proxy was initialized with.
-
#method_missing(method_name, *args, &block)
Delegate missing methods to the wrapped body.
-
#respond_to_missing?(method_name, include_all = false) ⇒ Boolean
Return whether the wrapped body responds to the method.
Constructor Details
.new(body, &block) ⇒ BodyProxy
Set the response body to wrap, and the block to call when the response has been fully sent.
# File 'lib/rack/body_proxy.rb', line 10
def initialize(body, &block) @body = body @block = block @closed = false end
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method_name, *args, &block)
Delegate missing methods to the wrapped body.
# File 'lib/rack/body_proxy.rb', line 45
def method_missing(method_name, *args, &block) case method_name when :to_str super when :to_ary begin @body.__send__(method_name, *args, &block) ensure close end else @body.__send__(method_name, *args, &block) end end
Instance Attribute Details
#closed? ⇒ Boolean
(readonly)
Whether the proxy is closed. The proxy starts as not closed, and becomes closed on the first call to close.
# File 'lib/rack/body_proxy.rb', line 40
def closed? @closed end
Instance Method Details
#close
If not already closed, close the wrapped body and then call the block the proxy was initialized with.
# File 'lib/rack/body_proxy.rb', line 28
def close return if @closed @closed = true begin @body.close if @body.respond_to?(:close) ensure @block.call end end
#respond_to_missing?(method_name, include_all = false) ⇒ Boolean
Return whether the wrapped body responds to the method.
# File 'lib/rack/body_proxy.rb', line 17
def respond_to_missing?(method_name, include_all = false) case method_name when :to_str false else super or @body.respond_to?(method_name, include_all) end end


This release includes a few new features and addresses over a dozen bugs in 0.7.0.
Add to_clipboard function to pandas namespace for writing objects to the system clipboard (GH774) Add itertuples method to DataFrame for iterating through the rows of a dataframe as tuples (GH818) Add ability to pass fill_value and method to DataFrame and Series align method (GH806, GH807) Add fill_value option to reindex, align methods (GH784) Enable concat to produce DataFrame from Series (GH787) Add between method to Series (GH802) Add HTML representation hook to DataFrame for the IPython HTML notebook (GH773) Support for reading Excel 2007 XML documents using openpyxl
Add to_clipboard function to pandas namespace for writing objects to the system clipboard (GH774)
to_clipboard
Add itertuples method to DataFrame for iterating through the rows of a dataframe as tuples (GH818)
itertuples
Add ability to pass fill_value and method to DataFrame and Series align method (GH806, GH807)
Add fill_value option to reindex, align methods (GH784)
Enable concat to produce DataFrame from Series (GH787)
Add between method to Series (GH802)
between
Add HTML representation hook to DataFrame for the IPython HTML notebook (GH773)
Support for reading Excel 2007 XML documents using openpyxl
Improve performance and memory usage of fillna on DataFrame Can concatenate a list of Series along axis=1 to obtain a DataFrame (GH787)
Improve performance and memory usage of fillna on DataFrame
Can concatenate a list of Series along axis=1 to obtain a DataFrame (GH787)
A total of 9 people contributed patches to this release. People with a “+” by their names contributed a patch for the first time.
Adam Klein
Brian Granger +
Chang She
Dieter Vandenbussche
Josh Klein
Steve +
Wes McKinney
Wouter Overmeire
Yaroslav Halchenko


These bubbles can be expanded by doubleclicking, and can be filled with any content.
To install the plugin, just add the bubbles.js and bubbles.css files in your project (get them HERE). When those files are in, make sure to link them in the html files you want to use bubbles. Bubbles requires jquery and jquery-ui.

Bubble One

I'm a bubble!

You can put almost anything inside here!!!

Remember to add the class "bubble", "reduced_body" and "expanded_body", and add this script on the bottom of your html:

Finally, you should declare the initial position of each bubble in your css, like this:
#bubble01 { top: 10px; left: 20px; }


Robin Williams
A deep and exuberent man who brought joy to many.
Robin Williams was a comedian and actor who had roles in a great deal of childrens films in the early 90s, and as such became a familiar face to many millenials. His roles ranged from silly, exuberent professor in Flubber..to the a that of a mentor in Good Will Hunting and Dead Poet's Society. In movies like Bird Cage and Mrs. Doubtfire he remained brilliantly funny while still showing a great deal of emotional depth in very serious situations that affected many growing up during the time period ranging from issues with sexuality (Bird Cage) to those of estrangement from parents (Mrs. Doubtfire).
Learn more about Robin Williams on Wikipedia.


Jade is a language which compiles to HTML.
This will not be an exhaustive document covering Jade but mainly covering conventions you'll see used in Kickstrap. For complete documentation, visit the Jade homepage.
Like CoffeeScript and Stylus, this language substitutes indentation for noisy characters.
For example, instead of

We can just write
div span nav
The closing of a tag is implied by beginning a new line indented back in. So if we wanted to say "hello" in the span, but not the nav, we'd say
div span | hello nav
The pipe (|) is a special character we use to tell jade that "hello" is not an html tag. Otherwise if we did this:
div span hello nav
We'd have this:

    <hello> </hello>

Commonly, you'll need to add classes and ids to your tags. This is done using CSS syntax where dots (.) are classes and hashmarks (#) are ids.
div.menu-item#main-menu
Would yield

Other attributes can be encapsulated by parentheses as such:
div.menu-item#main-menu(ng-click="activate()")
Yields:


--- layout: post status: publish published: true title: Cubs/Mets Trade of 2027 - Episode 7.19 author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 11197 wordpress_url: http://ivyenvy.com/?p=11197 date: '2015-05-13 22:09:29 +0000' date_gmt: '2015-05-14 03:09:29 +0000' categories: - Podcast tags: - New York Mets - Kris Bryant comments: - id: 18621 author: Painless_Dave author_email: '' author_url: '' date: '2015-05-19 03:54:56 +0000' date_gmt: '2015-05-19 08:54:56 +0000' content: I'm down with OBP. Yeah...you know me. ---
On this mid-week episode of the podcast, Andy and Corey comment on the first few games of the Cubs series with the Mets at Wrigley.
We spend a healthy amount of time talking about Kris Bryant's play, especially in Tuesday night's game. Jon Lester has a good outing and Jake Arrieta makes Corey look like he actually knows what he's talking about.
We also talk about the back end of the rotation and how any long winning streak is going to require the #4 and #5 spots in the rotation to provide a little more.
We answer a voicemail question from Josh in New Jersey. Josh asks about the rumored trade talks between the Cubs and Mets. We discourage you from reading too much into it...then we read too much into it.
Sean asks a question about closers in non-save situations. Michael asks about the Cubs hitting in the 7th inning and later.
If you have not yet filled out one of our listener surveys, we can finish this campaign with one final push. Please go to http://ivyenvy.com/survey. This should not take you more than 30 seconds and we'd really appreciate it.


handroll is a website generator designed to be simple and fast. You make content in your favorite format and handroll makes a website out of it.
Want to make a blog using Markdown? No problem. How about a personal website in reStructuredText? Sure thing. Maybe Textile is more your style. You’re good.
Quickstart
Get started fast with these commands!
$ pip install handroll $ handroll scaffold default mysite Complete. $ handroll watch mysite/source Serving /Users/matt/mysite at http://localhost:8000/. Press Ctrl-C to quit.
For more details, read on or go to the installation guide.
Who is this for?
handroll is for people who want to use plain text editors to make websites. That group could include programmers, writers, poets, and others.
handroll is a command line tool. In almost all cases, you will only ever need
to type handroll
, but a basic comfort level with a command line terminal is
beneficial.
What can it do?
- Make HTML from Markdown, reStructuredText, or Textile.
- Make CSS from Sass.
- Watch for changes as you work and automatically update your site.
- Track blog entries and generate a feed.
- Speak Arabic, Dutch, English, French, German, Greek, Italian, Portuguese, and Spanish.
You can find a full list of features in the developer documentation.
How much?
handroll is free and open source software. That means no cost to you. The tool is made available under the BSD license. In layman’s terms, the developers aren’t liable for anything.
Contributing
There are many ways to contribute to handroll.
- Start a discussion about a feature.
- Report a problem you’re experiencing.
- Translate for a new language or fix a broken one.
- Submit some code you wrote.
- Write a plugin for your favorite tool.
- Extend handroll in some new way.
The contributions of others will always be appreciated. Contributors of code or translations are recorded in the source code.
More information
Any other information can be found at the various sites used by the handroll project.
- GitHub project for source code and issues
- PyPI for package hosting
- Read the Docs for developer documentation
- Google Group for announcements and discussion
- Transifex project for language translation
- Travis project for Continuous Integration
- Codecov for source coverage measurement
- GitHub project for this website


Notebooks
Story: Ostriches and barter
Ostriches and barter
Title
Ostriches and barter
Collection
Summary
About the hunting of ostriches, the finding and drinking of ostrich eggs, the preparation and cooking of ostrich meat and the bartering of ostrich feathers for tobacco with white men. The verso notes accompanying this story describe the drinking of ostrich eggs. A note on p.752v describes the stirring of the ostrich egg with the /gipp (Proteles) tail hair brush and how this implement is used, as well as how the eggs are beaten. Another note on p.769v describes how thick /gipp hair (taken from its rear parts) is attached to the stick and used to stir and drink with. A note on p.776v describes the house of bushes made by the hunters on the hunting ground, to lie in and shoot ostriches from. Of Ostriches and Bushmen we have two accounts, a short one (B I. 295), and a long one which is a continuation of the myth of !káken !kaka !áuï (L II.-7. 737-797, 800-810). In the latter account, pp.780-782 treat of 'Poisoned Arrows'.
Comments
1) Date on p.743: 28 October; p.807: 7 November, 2) p.770v: the skimming off of fat from the surface of soup (using a stick with hair wound around it which is stirred around), 3) p.771v: a note by |a!kunta explaining the people's love and craving for tobacco (in their 'hearts'), 4) p.774v: the white men in the story are called the 'Boer's people', 5) p.783v: the sai bush, the Dutch name for !kwai (a poisonous bush that kills people if eaten), 6) p.785v: the method of cooking using heated stones, 7) p.804v: the riverbed mentioned in the story is that of the Kleine Hart River, 8) This story is found in Book II-7
Contributors
Date
October – November 1871
Categories
Custom and daily life, Relations with others
Keywords
ostriches (and |xam) , ostriches (their spoor) , ostriches (different names and kinds of) , ostriches (their eggs) , ostriches (their houses or nests) , ostriches (the nature and habits of) , ostriches (their feathers) , ostriches (their body parts) , ostriches (meat from) , ostriches (the hunting of) , ostriches (making soup from) , ostriches (eating their fat) , ostriches (their flesh) , ostriches (and bartering) , hunting (methods for ostrich) , hunting (house of bushes used) , hunting (weapons and implements used in) , hunting (ostriches and barter) , ostrich feathers (bartering) , feathers (ostrich) , feathers (bartering of ostrich) , bartering (with white men) , bartering (and ostriches) , bartering (for tobacco) , bartering (of ostrich feathers) , ostrich eggs (methods of drinking) , ostrich eggs (finding) , ostrich eggs (implements used for drinking) , cooking (pot) , cooking (implements) , cooking (ostrich eggs) , cooking (fires) , cooking (methods of) , poison (and hunting ostrich) , food (methods of drinking ostrich eggs) , food (cooking ostrich meat) , food (eating and bartering ostriches) , names (of ostrich eggs) , tobacco (bartering of ostrich feathers and)
Story Pages
737-797, 800-810


FEZ Hydra Developers' Guide
FEZ Hydra is a 100% open source hardware (OSHW). This means, hardware design files are made public and the software running the board is made public as well. Even better, FEZ Hydra hardware is designed with EAGLE, one of the most popular design tools and the software is developed on the free, open source GCC compiler.
Licensing
The design files are available to everyone to use, even commercially. The software is licensed using Apache2. This license allowing for changes, for commercial use and for even close sourcing the derived designs. The hardware is licensed using Creative Commons Share Alike 3.0. This license allows for commercial use and for derived work but doesn't allow close sourcing the derived work. Please contact GHI if you need to close source your derived work.
Note that the FEZ nor the FEZ Hydra name are licensed for use. GHI is licensing the designs as outlined above, even for commercial use, but is not giving any rights to use the any GHI Electronics's trademarks. Check the link above for full details on the license. If you are making your own commercial product, you should have a completely different and distinctive name. Using derived names or similar names will only confuse your own customers and GHI's customers.
GHI is interested in learning about what you are doing with FEZ Hydra design files. We can help you even further; so, please consider contacting GHI directly with info about your project.
To properly attribute this work, your board should say
Based on GHI's OSH FEZ Hydra
and your website and all documentation should say
Based on GHI Electronics' Open-Source-Hardware FEZ Hydra design files.
Visit this page for more details http://www.ghielectronics.com/docs/39/fez-hydra-developer
The open-source Files
FEZ Hydra EAGLE design files are found here.
The files are provided AS-IS.
FEZ Hydra software components are available at https://bitbucket.org/ghi_elect/netmf-open-firmware
To build the software, you need RVDS or GCC compilers.
This page covers more details on using GCC on building your own firmware FEZ Hydra Firmware.
Real Time Clock
For the Real Time Clock to function, VBAT must be supplied with 1.2 volts.
RLP
RLP on the FEZ Hydra is a bit different than our other offerings. We do not support parsing ELF files. You must compile your native code into a raw binary image and load it using our AddressSpace class to the RLP address of 0xA0000000. You must find the address of your desired function in the map file that the compiler produces and construct a NativeFunction object manually using that address. Invocation and parameter passing function identically, except that RLP extensions (the RLP.h file) are not supported. The FEZ Hydra folder in the samples archive linked on the RLP page contains a Keil uVision project. It is already configured and references the NativeCode.c file. Just open the project in uVision and build it after you have made your changes to NativeCode.c. For advanced users creating their own project, you want to compile from the Atmel AT91SAM9RL64 processor with an R/O base of 0xA0000000 and R/W base of 0xA0080000. Make sure that you convert any generated ELF file into a raw binary file.
Feature Set
As FEZ Hydra has been released as open source, some of the features found in other GHI Electronics' products are not available. The following are not supported:
- SPI display configuration
- Non-blocking Signal Generator
- CAN
- Play PCM audio
- Bitmap convert to file
- Watchdog
- RLP ELF file parsing
- RTC Alarm
- Hibernate
- InField Update
- Startup Logo
- SD card detection
- BuiltInEthernet
- Wi-Fi RS9110
- PPP
- SQLite
- USB host
- USB client
- Passing bitmaps to RLP
- Bitmap get and set internal buffer
- SSL
- UART handshaking
- Configuration read and write
- Pulse capture
Known Issues
Sockets 3 and 4 should be labeled SX and SUX respectively. Type K on socket 6 is also not available.
Loader Update
To update the loader, you must erase the device and then deploy the new loader. To begin, disconnect all modules, connect pin eight on socket three or four to ground, power the board, wait five seconds, then unconnect the pin. If your FEZ Hydra has a small button just above socket 9, you can hold that down while powering the board instead of grounding pin 8. After you do that, the device will show up as a COM port in the Devices and Printers menu in Windows. Make note of the COM port number. Navigate to: C:\Program Files (x86)\GHI Electronics\GHI NETMF v4.3 SDK\Firmwares\FEZ Hydra\Loader. Right click on Update.bat, click Run As Administrator, and follow the instructions. "Updating" should be displayed on the screen for several minutes. Once "Done" is displayed, reset the device, and deploy the firmware using FEZ Config as detailed on the Firmware Update page.
Tip
If "Updating" is only displayed for a few seconds before done is display, the update did not complete. The Log.txt file created in the same directory can help diagnose the problem.


Ocean [aw46], ocean, in The Inner Sea
Last updated Turn #78
Ocean [aw46], ocean, in The Inner Sea
------------------------------------------------------------------------
8: The Savvy Aardvark [ha5r], ship, 2 hulls, 1 rowing port, 6 sails,
8: 9% damaged, arrived from Ocean [av46], owner:
8: Phantasm [n4b], Imperial Empire, marquess, with two peasants,
8: eight sailors
9: The Savvy Aardvark [ha5r], ship, 2 hulls, 1 rowing port, 6 sails,
9: 9% damaged, departed for Ocean [aw45].
Routes leaving Ocean:
North, to Ocean [av46], 6 days
East, to Ocean [aw47], 6 days
South, to Ocean [ax46], 6 days
West, to Ocean [aw45], 6 days
It is raining.


Powerfoil X3.0’s superior hub and airfoil systems deliver unmatched airflow to big spaces, powered by a purpose-built NitroSeal™ drive system and supported by world-class safety features. With premium materials and precise engineering, Powerfoil X3.0 offers the custom fit to improve comfort, safety, and efficiency in any application.
click each button to learn more about that option.
Footer


The F_worlds Society started as a loose collective of friends who gathered to play games in late 2017.
Our first adventure was an epic realm-spanning fantastical sci-fi Shadowrun adventure set in a cthuluian invasion of a world our questors got transported to through a time- and space-warping portal. After months of travails, they defeated the marauding Elder God and were able to return to their own world.
Emboldened by this {extreme fun}, we decided to keep on playing.
Gloomhaven came out, and we set off on more whirlwind adventures: smashing monsters, hunting necromancers, and exploring the world. Unfortunately one of our members moved to a far, far off land, hindering our boardgame progression.
So, we switched back to Shadowrun (3rd edition, the one that counts). Striving to stop the takeover of the world by the mad Renraku AI, DEUS, our adventures are all that stand between humanity and certain chaos.
Follow along, dear readers, as we embark on more exploits with other systems (adorable little mice, with swords!), other worlds, and other players.
We love playing games. Long ones. Complicated ones. Ones with epic plots.
I wish we had started chronicling them long ago. Meager though they may be, here are our journals.


Delegated Proof of Stake (DPOS) is the fastest, most efficient, most decentralized, and most flexible consensus model available. DPOS leverages the power of stakeholder approval voting to resolve consensus issues in a fair and democratic way. All network parameters, from fee schedules to block intervals and transaction sizes, can be tuned via elected delegates. Deterministic selection of block producers allows transactions to be confirmed in an average of just 1 second. Perhaps most importantly, the consensus protocol is designed to protect all participants against unwanted regulatory interference.
BitShares is first and foremost a globally distributed database that is used as a ledger to track ownership of digital assets. All updates to the ledger must be validated and applied in the proper order to allow the database to remain consistent and universally agreed upon. Reaching a consensus about the order in which updates should be applied is the purpose of Delegated Proof of Stake (DPOS).
Overview
The questions that must be answered by any consensus process include, but are not limited to:
- Who should produce the next block of updates to apply to the database?
- When should the next block be produced?
- What transactions should be included in the block?
- How are changes to the protocol applied?
- How should competing transaction histories be resolved?
The goal is to find answers to these questions that ensure the consensus process is robust against an attacker who wishes to gain control over the network. In practice, gaining control means acquiring the ability to unilaterally censor transactions. The process should also be robust against an attacker wishing to take advantage of a temporary inconsistency in the database state on different computers.
Block Production by Elected Witnesses
The term witness was chosen because it is a legally neutral word that is free from regulation. Traditional contracts often have a place for witnesses to sign. For extremely important contracts, a public notary is sometimes used. Neither witnesses nor notaries are party to the contract, but they serve a very important role of certifying that the contract was signed by the specified individuals at the specified time. In BitShares, witnesses serve a similar role of validating signatures and timestamping transactions by including them in blocks.
Under DPOS, the stakeholders can elect any number of witnesses to generate blocks. A block is a group of transactions which update the state of the database. Each account is allowed one vote per share per witness, a process known as approval voting. The top N witnesses by total approval are selected. The number (N) of witnesses is defined such that at least 50% of voting stakeholders believe there is sufficient decentralization. When stakeholders expresses their desired number of witnesses, they must also vote for at least that many witnesses. A stakeholder cannot vote for more decentralization than witnesses for which they actually cast votes.
Each time witnesses produce a block, they are paid for their services. Their pay rate is set by the stakeholders via their elected delegates (to be discussed later). If a witness fails to produce a block, then they are not paid, and may be voted out in the future.
The slate of active witnesses is updated once every maintenance interval (1 day) when the votes are tallied. The witnesses are then shuffled, and each witness is given a turn to produce a block at a fixed schedule of one block every 2 seconds. After all witnesses have had a turn, they are shuffled again. If a witness does not produce a block in their time slot, then that time slot is skipped, and the next witness produces the next block.
Anyone can monitor network health by observing the witness participation rate. Historically, BitShares has maintained 99% witness participation. Any time witness participation falls below a certain level, users of the network can allow more time for transactions to confirm, and be extra vigilant about their network connectivity. This property gives BitShares the unique advantage of being able to alert users of potential problems less than 1 minute after the trouble arises.
Parameter Changes by Elected Delegates
Delegates are elected in a manner similar to witnesses. A delegate becomes a co-signer on a special account that has the privilege of proposing changes to the network parameters. This account is known as the genesis account. These parameters include everything from transaction fees, to block sizes, witness pay, and block intervals. After the majority of delegates have approved a proposed change, the stakeholders are granted a 2 week review period during which they may vote out delegates and nullify the proposed changes.
This design was chosen to ensure that delegates technically have no direct power and that all changes to the network parameters are ultimately approved by the stakeholders. This is done to protect the delegates against regulations that may apply to managers or administrators of cryptocurrencies. Under DPOS, we can truly say that the administrative authority rests in the hands of the users, rather than either the delegates or witnesses.
Unlike witnesses, delegates are not paid positions. However, these parameters are not expected to change often.
The genesis account can technically perform any action that any other account can perform, which means it is possible to send funds to the genesis account or specify the genesis account as an escrow agent. The genesis account can also be used to issue new assets. There are untold number of applications where elected delegates can aid the stakeholders in performing tasks that demand a high degree of trust and accountability.
Changing the Rules (aka Hard Forks)
From time to time, it is necessary to upgrade a network to add new features. Under DPOS, all changes must be triggered by active stakeholder approval. While it is technically possible for the witnesses to collude and change their software unilaterally, it is not in their interest to do so. Witnesses are selected based upon their commitment to remain neutral to blockchain policy. Remaining neutral protects witnesses against allegations that they are the administrators/managers/owners/operators of the network. A witness is merely an employee of the stakeholders.
Developers may implement whatever changes they deem appropriate, so long as those changes are contingent upon stakeholder approval. This policy protects the developers as much as it protects the stakeholders and ensures that no individual has unilateral control over the direction of the network.
The threshold for changing the rules is the same as replacing 51% of the elected witnesses. The more stakeholder participation in electing witnesses, the harder it becomes to change the rules.
Ultimately, changing the rules depends upon everyone on the network to upgrade their software, and no blockchain level protocol can enforce how rules are changed. This means that hard-forking “bug fixes” can be rolled out without requiring a vote of the stakeholders, so long as they remain true to the universally expected behavior of the code.
In practice, only security critical hard-forks should be implemented in such a manner. The developers and witnesses should wait for the stakeholders to approve even the most minor changes.
Double Spend Attack
A double spend can occur anytime a blockchain reorganization excludes a transaction previously included. This means that the witnesses had a communication breakdown caused by disruptions in the infrastructure of the Internet. With DPOS, the probability of a communication breakdown enabling a double spend attack is very low.
The network is able to monitor its own health and can immediately detect any loss in communication which shows up as witnesses failing to produce blocks on schedule. When this occurs, it may be necessary for users to wait until half of the witnesses have confirmed their transactions, which could be up to a minute or two.
Transactions as Proof of Stake
Each transaction on the network may optionally include the hash of a recent block. If this is done, the signer of the transaction can be confident that their transaction may not be applied to any blockchain that does not include that block. A side effect of this process is that, over time, all stakeholders end up directly certifying the long-term integrity of the transaction history.
Blockchain Reorganizations
Because all witnesses are elected, highly accountable, and granted dedicated time slots to produce blocks, there is rarely any situation where two competing chains can exist. From time to time, network latency will prevent one witness from receiving the prior block in time. If this happens, the next witness will resolve the issue by building on whichever block they received first. With 99% witness participation, a transaction has a 99% chance of being confirmed after a single witness.
While the system is robust against natural chain reorganization events, there is still some potential for software bugs, network interruptions, or incompetent or malicious witnesses to create multiple competing histories that are longer than a block or two. The software always selects the blockchain with the highest witness participation rate. A witness operating on their own can only produce one block per round and will always have a lower participation rate than the majority. There is nothing that any witness (or minority group of witnesses) can do to produce a blockchain with a higher participation rate. The participation rate is calculated by comparing the expected number of blocks produced vs the actual number of blocks produced.
Maximally Decentralized
Under DPOS, every stakeholder has influence that is directly proportional to their stake, and no stakeholders are excluded from exercising this influence. Every other consensus system on the market excludes the vast majority of stakeholders from participating. There are many different ways that alternatives exclude stakeholders. Some alternatives use invite-only systems. Others exclude participation by making it cost more to participate than they earn. Still other systems technically allow everyone to participate, but they can be safely ignored by a few large players who produce the vast majority of all blocks. Only DPOS ensures that block production is evenly distributed among the most people and that everyone has an economically viable way to influence who those people are.


| HOME | DOWNLOAD | DOCUMENTATION | FORUM | FAQ |
> Home > Documentation > Spherical Harmonic Rotations
SHROTATECOEF(1) SHTOOLS 2.6 SHROTATECOEF(1)
SHRotateCoef
SHRotateCoef - Determine the spherical harmonic coefficients of a complex function rotated by three Euler angles.
SYNOPSIS
SUBROUTINE SHRotateCoef ( X, COEF, RCOEF, DJ, LMAX ) REAL*8 X(3 ), COEF(2, (LMAX+1)*(LMAX+2)/2), RCOEF(2, (LMAX+1)*(LMAX+2)/2), DJ(LMAX+1, LMAX+1, LMAX+1) INTEGER LMAX
DESCRIPTION
SHRotateCoef will take the complex spherical harmonic coefficients of a function, rotate it according to the three Euler anlges in X, and output the spherical harmonic coefficients of the rotated function. The input and output coefficients are in an indexed form that can be converted to and from CILM(2,:,:) form by using the functions SHCilmToCindex and SHCindexToCilm. The coefficients MUST correspond to unit-normalized spherical harmonics that possess the Condon-Shortley phase convention. Real spherical harmonics can be converted to and from complex form using SHrtoc and SHctor. The input rotation matrix DJ is computed by a call to DJPi2. The rotation of a coordinate system or body can be viewed in two complementary ways involving three successive rotations. Both methods have the same initial and final configurations, and the angles listed in both schemes are the same. Scheme A: (I) Rotation about the z axis by alpha. (II) Rotation about the new y axis by beta. (III) Rotation about the new z axis by gamma. Scheme B: (I) Rotation about the z axis by gamma. (II) Rotation about the initial y axis by beta. (III) Rotation about the initial z axis by alpha. The rotations can further be viewed either as a rotation of the coordinate system or the physical body. For a rotation of the coordinate system without rotation of the physical body, use X(alpha, beta, gamma). For a rotation of the physical body without rotation of the coordinate system, use X(-gamma, -beta, -alpha). To perform the inverse transform of X(alpha, beta, gamma), use X(-gamma, -beta, -alpha). Note that this routine uses the "y convention", where the second rotation is with respect to the new y axis. If alpha, beta, and gamma were orginally defined in terms of the "x convention", where the second rotation was with respect to the newx axis, the Euler angles according to the y convention would be alpha_y = alpha_x - pi/2, beta_x = beta_y, and gamma_y = gamma_x + pi/2.
ARGUMENTS
X (input) REAL*8, DIMENSION(3 ) The three Euler angles, alpha, beta, and gamma. COEF (input) REAL*8, DIMENSION (2, (LMAX+1)*(LMAX+2)/2) The input complex spherical harmonic coefficients. This is an indexed array where the real and complex components are given by COEF(1,:) and COEF(2,:), respectively. The functions SHCilmToCindex and SHCindexToCilm are used to convert to and from indexed and CILM(2,:,:) form. The coefficients must correspond to unit-normalized spherical harmonics that possess the Condon-Shortley phase convention. RCOEF (output) REAL*8, DIMENSION (2, (LMAX+1)*(LMAX+2)/2) The spherical harmonic coefficients of the rotated function in indexed form. DJ (input) REAL*8, DIMENSION (LMAX+1, LMAX+1, LMAX+1) The rotation matrix DJ(pi/2), obtained from a call to DJPi2. LMAX (input) INTEGER, OPTIONAL The maximum spherical harmonic degree of the input and output coefficients.
NOTES
This routine is based upon code originally written by Guy Masters, which was then subsequently modified by Mark Simons and myself.
SEE ALSO
djpi2(1), shrotaterealcoef(1), shctor(1), shrtoc(1), shcilmtocindex(1), shcindextocilm(1) <http://www.ipgp.jussieu.fr/~wieczor/SHTOOLS/SHTOOLS.html>
COPYRIGHT AND LICENSE
Copyright 2005, 2006 by Mark Wieczorek<EMAIL_ADDRESS>This is free software; you can distribute and modify it under the terms of the revised BSD license. SHTOOLS 2.6 2009-08-18 SHROTATECOEF(1)
> Home > Documentation > Spherical Harmonic Rotations
| Centre National de la Recherche Scientifique | Institut de Physique du Globe de Paris | © 2011 Mark Wieczorek |


Apple to bring Augmented Reality headset in 2022, glasses by 2023
Apple is expected to release the AR headset in 2022 while the AR Glasses would release in 2023, Engadget reported.
by ANIThe next product to come from Apple's AR division will be a headset, according to the latest reports.
Apple is expected to release the AR headset in 2022 while the AR Glasses would release in 2023, Engadget reported.
The purported AR headset is speculated to resemble an Oculus Quest with high-resolution eyepieces. Meanwhile, the AR glasses are expected to resemble high-end sunglasses with thick frames to house the battery and processors.


Neev is the first formal introduction of the freshers to the department and to all its members. Along with the Fresher's welcome, an open house is also conducted to discuss the things going on in the department.
5th September is celebrated very heartedly here with active participation both from the faculty side as well as the student side! Various fun events are conducted to entertain the crowd as well as the faculty.
"Good byes are tough ..... but in this senario the word ends next to success in education and knowledge. It may be harder for the person who is leaving but it is always hardest for the person left behind". The event was a bitter-sweet occassion. It was indeed a sad day to bid good bye to our seniors who were ending their remarkable journey at college.
The first bridges built by humans were probably just wooden planks or boulders placed on a flowing stream. But today, engineers have built bridges to cross vast stretches of rivers. Before actually constructing a bridge, we need to model it and test its performance in the lab.
Spagaridge brings you a chance of showing your engineering skills with noodles!
So, get innovative and build your bridge model with this unconventional construction material.
Think your designing skills are better than all? Than prove it to us by taking this challenge. Celesta presents CAD Maestro, the design event. Design the CAD model of the proposed problem and send it to us! The best design wins! Problem statement will be released soon, please follow our Facebook page, Twitter handle, official website and official app for further updates.
Wanna build structures? Can't wait for becoming old enough? Or have the perfect sense and not the material? Then this is for you. House of Cards is a fun event where you can build structures with cards! ACEbrings to you an opportunity to build 3D Structures with Cards in this two round event. Let your passion show its colors and let your talent and creativity be in continuous flow! This is House of Cards!
ACE organised this site visit that aimed at enlightening the students about the various aspects of on-site construction in order to provide them an opportunity to increase their knowledge base outside of regular academic coursework. Dr. Amarnath Hegde came to enlighten us during the visit.
Every year we at ACE conduct a football tournament for the members of DCEE so that they can be a part of sport. Here all the members of the DCEE take part and enjoy the weekend by playing football. The tams are a combination of Faculty, B.Tech and M.Tech Students.
Every year we at ACE conduct a cricket tournament for the members of DCEE so that they can be a part of sport. Here all the members of the DCEE take part and enjoy the weekend by playing cricket. The tams are a combination of Faculty, B.Tech and M.Tech Students.


Equality for Women?
The development of women's distance running has often been warped and restricted by the largely male athletics
establishment. Unfortunately women accepted, and even on occasion, colluded and embraced these restrictions.
As a result generations of women were denied their chance of greatness, their potential remaining under-developed
and unknown.
In the First World War women had been required to undertake much of the work which had previously been the province
of men. Having been allowed to escape from the previous restrictions of female life, women now wanted to take part
in other areas of life which had formerly been a male preserve. Thus it was that women's amateur athletics began
to develop in Europe. In 1919, the Federation Feminine Sportive de France asked the International Olympic Committee
to include women's events in the Olympic Games but the idea was rejected. This spurred the women's movement to
create their own Women's Games.
The first true international meeting for women was conducted at Monte Carlo in 1921. Five countries were represented
in eleven events and it was such a success that the Games were repeated the following year with an increase in
the number of athletes, teams and events.
By this stage the Federation Sportive Feminine Internationale [FSFI] had been formed by women from six countries
and had developed regulations for the conduct of women's events. The first Women's Olympic Games was held in Paris
and five countries fielded teams. Eighteen world records were broken during the Games and it was decided to hold
the next Olympiad for women in 1926.
By the time the second women's games were held the International Olympic Committee and the International Amateur
Athletic Federation [IAAF] had forced a name change. However the Women's World Games in Gothenburg were even more
successful than the first.
Realising that they could not ignore women any longer, and wishing to have control of this new, highly successful
movement, the IAAF had voted to include women's events in the 1928 Olympic Games. The vote was passed 12-5.
A priority list of events to include was drawn up by the FSFI in the following order: 100m, 4x100m relay, High
Jump, Discus, Javelin, 800m, Long Jump, Hurdles, Shot Putt and 200m. Only the first four events and the 800m were
approved for competition at the Amsterdam Games in 1928. The 800 metres was to be the crucial event. The final
saw Lina Radke of Germany set a world's record, but most of the under-trained runners found the race very hard.
Six out of the nine runners collapsed with exhaustion, and several had to be carried from the track. It should
be noted that the humidity was recorded as being at 93% during at least part of the Games. Moreover it should
be also be recorded that the great Paavo Nurmi, who won the 5000 metres at the same Olympics, was also exhausted
when he finished his race and "and lay down on the grass for several minutes". However it was thought
inappropriate and offensive for the fairer sex to be exhausted! The IAAF decided six days after the race to keep
women's events in the Olympic Games, but to restrict the number of events drastically. The 200 metres and 800 metres,
long jump and shot put were rejected. Only six women's events were to be included in the 1932 Olympics, as compared
to 24 men's events.
In one fell swoop the IAAF had taken over women's athletics and reduced it to a token handful of events. They
"set women's distance running back 40 years at least ".
Interestingly in Britain the 880 yards for women continued to be included in every WAAA Championships from that
date onwards and the 800 metres in the fourth women's World Games in 1934 which were held in Britain. In 1936 the
English Women Amateur Athletics Association instituted a mile championships for women , won by Gladys Lunn ran
5:23.0. Thus the presumption must be that for some authorities, the IAAF/IOC's decision was seen as an over-reaction.
In 1936 the FSFI merged with (or perhaps `was subsumed by' would be more accurate) the IAAF. It was to be many
years before the ten events proposed by the FSFI were to be incorporated in the Olympics. It was not until 1948
that women were even allowed to contest the 200 metres in the Olympics. The highly controversial 800 metres had
to wait thirty-two years until it was reinstated, and the 400 metres thirty-six years.
But distance running took even longer overcome the false perception of female frailty. Despite women setting six-day
and one thousand mile marks in the 1870s, and more recently breaking five minutes for the mile, running marathons
and even completing the 100km and 24 hours, it was not until 1972 that the 1500 metres was included.
It was to take a series of women-only marathons in Atlanta [1978], Waldniel [1979], London [1980], Ottawa [1981],
San Francisco [1982], Osaka [1982] and Los Angeles [1983], which greatly increased the number and quality of runners
and national participation, allied to national championships being established some ten years earlier [Germany
1973; USA 1974] and the European Championships marathon [1982], to persuade the IOC in 1982 to permit an Olympic
Marathon. [Perhaps even more important may have been the fact that many of these all-women events had the support
of a major sponsor!] The 3000 metres was also included as a timid step towards distance running - it had been held
in the European Championships ten years earlier!
However the IOC was still set against the full development of women's endurance events in the Olympics, despite
the fact women had been running 10,000 metres on the track for some ten years.
Prior to the 1984 Olympics, legal efforts were made by the "International Runners Committee" to get
the 5000 metres and 10,000 metres added to the Los Angeles programme. The case was fought on the grounds of discrimination
against women but failed to get through the US courts. However the impact of the case on the IAAF and IOC was
significant. Within the next four years the 10,000 metres was added to the programme of major games, women's walking
races were added as Olympic demonstration events and the IAAF recognised women's world running track records
at 5,000 metres, the Hour, 20km, 25km and 30km.. In 1988 came IAAF recognition of the 100km championships, which
also included a race for women.
Interestingly when the IAAF selected the 5000 and 10,000 metres marks to be the recognised IAAF world records,
they selected those made by Paula Fudge (Britain) 15:41.51 and Yelena Sipatova (USSR) 32:17.19. These marks had
been made in women-only races. Superior performances had been set by Loa Olafsson of Denmark of 15:08.8 and 31:45.35
but these had been set in mixed races against men. The IAAF ignored Olafsson's markedly superior marks in preference
to those set in all-women events
The major championship distance events of the 70s and 80s - the 1500 metres and 3000 metres - were largely
to be dominated by the Eastern block, with its emphasis of speed and endurance. The pressure to extend the range
of running events upwards opened up women's athletics to a much wider spectrum of athletes, particularly those
from African and Asia.
Recently the IOC/IAAF seem to have become major converts to women's equality. In 1996 the triple jump was added
to the Olympics, in 2000 the pole vault and hammer and in the 2005 World Championships, the 3000 metre steeplechase.
Most recently we have women's road records being recognised by the IAAF. Why this sudden change of heart after
all these years?
During the 1980s and 1990s the world sporting arena changed as television became a voracious consumer. Sport was
relatively cheap and attractive for television companies. Television coverage meant the influx of funding from
sponsors into sport. As the knowledgeable Peter Matthews, editor of the ATFS annual wrote in 2002, "Athletics
has to fight the domination of football…and must maintain favourable publicity in order to maintain major places
in the hugely competitive sporting calendar". However the IAAF had hit a major problem. Its most exciting
product - world records - were .becoming in short supply. The "near-inevitable `failure' of such record
attempts was producing negative comments in the media.
In 2000 there was no world record at any standard men's event, the first time this had happened since 1907; there
were none at any of the traditional women's events. . In 2000 the only new world records were in the new events,
the triple jump, hammer and pole vault! The expansion had been necessary to provide "new world records".
Now of course, another event the steeplechase is added to the world record schedule. The suspicion must be that
it is not the needs of women but the needs of the media which have dictated these decisions.
These field events would not supply the continual supply of world records that the IAAF needed. So most recently
the IAAF have recognised road marks as world records. Despite the fact that the crucial original recognition
of the marathon for the Olympics and other major championships was based on all-women events, and despite the previous
precedent of the recognition criteria used for the 5000 and 10,000 metres world records, the IAAF went for female
marks paced by male runners set mixed races.
Why was this? The IAAF had learned from the experiences of the track scene. Left to their own devices, runners
would not produce enough world records. Pacers had been introduced, which initially had offered a more reliable
guarantee of records. Desperate for records at any costs, the IAAF went for what they saw as the best guarantee
of world records, women being paced by men.
Perhaps in the end this "commercial logic" may be just an excuse. The IAAF male establishment is unwilling
to allow women distance road runners their chance to show to the millions of spectators the potent symbol of
women competing alone against distance and time The presence of male pacers provide that clear evidence that mere
feeble women cannot achieve such performances on their own, that women are still being manipulated by men.
It seems the prejudices of the male athletic establishment which have hindered the development of women's distance
running for over seventy years still remain.

Nearly seventy years ago in Durban, South Africa Geraldine Watson ran 100 miles inside 23 hours despite strong
gusting winds and rain. These women showed the endurance potential of women. It has taken a prolonged battle
against the athletics establishment since then to achieve some semblance of parity with male distance runners.
There are still battles to be fought; women deserve their place alone in the spotlight, unencumbered by the
implicit male superiority imposed by male pacemakers.
Andy Milroy


LightWalletGrpcService |
Implementation of LightwalletService using gRPC for requests to lightwalletd. class LightWalletGrpcService : LightWalletService |
LightWalletService |
Service for interacting with lightwalletd. Implementers of this service should make blocking calls because async concerns are handled at a higher level. interface LightWalletService |


{{ stringInterpolation }}
{{ numberInterpolation }}
This is ngClass directive binding
This is ngStyle attribute binding


--- title: Israel shot 186 date: 2004-07-05T00:00:00.000Z filepathOriginal: photos/IMG0093.jpg filepathThumbnail: photos/IMG0093.thumbnail.jpg filepathPreview: photos/IMG0093.preview.jpg ---
Hi hoe, Hi hoe, it's off to plant we go - Academy 2 with a bunch of hoes


Our work
Describe the video you add to this section. Add the link to your Youtube channel or your gallery page to the button shown below. Bootstrap Landing Page Template.
Sibongumusa's Restaurant
Describe the video you add to this section. Add the link to your Youtube channel or your gallery page to the button shown below. Bootstrap Landing Page Template.


Hope you are having an amazing day!
This email is a reminder for you to complete the payment of your hotel booking reservation at Ophelia\'s Oasis.
Here are your booking details:
Name: Pavan Mahadik
Reservation Start Date: 2019-10-10
Reservation End Date: 2019-10-11
Number of Rooms Booked: 3
Total Amount: $300
Amount Paid: $0
Amount Payment Deadline: 2019-08-05
Please click the below button to complete your payment:
Note: If payment is not done in 15 days, your reservation will be cancelled and no refund will be made.
Any problems? Call our 24x7 helpline: 1800-000-0000
Copyright © Ophelia\'s Oasis 2019


Noise functions are stochastic functions that can be used to increase visual complexity. More...
Functions | |
| template<typename genType > | |
| genType::value_type | noise1 (genType const &x) |
| template<typename genType > | |
| detail::tvec2< typename genType::value_type > | noise2 (genType const &x) |
| template<typename genType > | |
| detail::tvec3< typename genType::value_type > | noise3 (genType const &x) |
| template<typename genType > | |
| detail::tvec4< typename genType::value_type > | noise4 (genType const &x) |
Noise functions are stochastic functions that can be used to increase visual complexity.
Values returned by the following noise functions give the appearance of randomness, but are not truly random.
| genType::value_type glm::noise1 | ( | genType const & | x | ) |
Returns a 1D noise value based on the input value x.
| genType | Floating-point scalar or vector types. |
| detail::tvec2<typename genType::value_type> glm::noise2 | ( | genType const & | x | ) |
Returns a 2D noise value based on the input value x.
| genType | Floating-point scalar or vector types. |
| detail::tvec3<typename genType::value_type> glm::noise3 | ( | genType const & | x | ) |
Returns a 3D noise value based on the input value x.
| genType | Floating-point scalar or vector types. |
| detail::tvec4<typename genType::value_type> glm::noise4 | ( | genType const & | x | ) |
Returns a 4D noise value based on the input value x.
| genType | Floating-point scalar or vector types. |


Listed below are the key things I was involved with doing this week..
- Students & Graduates Q&A meetup
- Having organised the meetup session, it finally took place this week and It was a big success, there was about 20 students and graduates altogether, and it was a good opportunity for students to ask the graduates questions about their life before their graduate scheme (i.e, Uni, previous placements, final year projects, etc), and their life since starting the graduate scheme at STFC (i.e, the work enviroment, what the graduate scheme is like in general, what you get to be involved in, etc etc..). It ended up being a very interactive session.. and I got good feedback from some of the students and graduates involved afterwards..
- Powershell Scripts for Administrating Sharepoint 2013
- This week, I spent time working on writing Powershell scripts for the creation of certain components for the new "Science Interaction sites" project that the team is currently embarking on. The scripts create elements like content type, columns, etc on a Sharepoint site. This is all done for the sake of being able to automate the task, and also because there is actually a fair few amount of things that needs to be created (and scripting seems to be the best option to do things quickly)
Listed below are the key things I was involved with doing this week..
- Computing Group Meeting - Talk was on "Keeping Data and being able to retrieve it with the right Meta-data"
- There was the computing Group meeting this week which was where we get updates in regards to what other teams in the computing groups are up to.
The talk at the meeting was given by a Lady from the Scientific Computing Department at STFC, and her talk was mainly on Keeping Data (like software) and applying metadata to the data so that years down the line they can still be recognisation and understood (even if its no longer relevant and useful)...
- Powershell Scripts for Administrating Sharepoint 2013
- Still mainly working on writing powershell scripts for Sharepoint site creation
Listed below are the key things I was involved with doing this week..
- SLM Meeting
- I had a Appraisal meeting with my SLM (Senior Line Manager) this week to talk about my experience so far and looking forward.
- More Powershell scripting
- I have been able to learn using Powershell functions, modularising functions (to reduce code duplications, i.e, scripts could be imported into other scripts dynamically), using data sturctures like Powershell's hashtable,etc


D-Tox / Eye See You
D-Tox is a movie starring Sylvester Stallone, Charles S. Dutton, and Polly Walker. A lead detective being stalked by a serial killer is asked to check into a clinic treating law enforcement officials who can't face their jobs.


The Designer - Mariessa
Loves, Mariessa is an independent Fashion Designer from Austin, Texas. She was raised in Atlanta, GA and started designing clothes at the age of 15.  Mariessa then attended Bauder Collage in Atlanta and was schooled the technicalities of the fashion industry. After some time in college in Georgia, she moved to Austin and then traveled to the West Coast. She attended the local community college out West, Monterey Peninsula College, and took some patterns and alterations classes. Mariessa has produced fashion shows in Georgia, California, and many here in Austin, Texas.
Her brand is centered around creating classy attire for men and women, but she has done a great deal of costume/custom piece work
Mariessa's achievements include winning Best Fashion Designer award for Austinâs Most Fashionable with FABRICATION 6 in November of '08, and also being featured in the Imaginations! SXSW Spring '09 Fashion Show at SXSW Interactive. Mariessa has been a large supporter for local artistry, and she has also spent a great deal of time working with others in the creative industry.


The Title of Your Web Page
Hello there, awesome person!
A List of Lists
The following is a list containing two lists: a list of URLs and all other lists
A list of URLs
Latex -
Multiple Types of Bulleted Lists in Sublists in Beamer
Unistalling Extraneus Language Optional Features on WX
Tables
of Totally Real Number Fields
Other Lists


Do not construct this object directly, use the endpointConfigurations
property of an Ngrok
client object instead.
Create a new endpoint configuration
Delete an endpoint configuration. This operation will fail if the endpoint configuration is still referenced by any reserved domain or reserved address.
Returns detailed information about an endpoint configuration
Returns a list of all endpoint configurations on this account
Updates an endpoint configuration. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
Generated using TypeDoc
Endpoint Configurations are a reusable group of modules that encapsulate how traffic to a domain or address is handled. Endpoint configurations are only applied to Domains and TCP Addresses they have been attached to.


--- layout: page title: Community Consultants permalink: resources/consultants ---
A curated list of consultants who help organizations build communities.
Erica's goal is to help companies create authentic, engaged, and empowered communities.
Gather helps small businesses, entrepreneurs, and enterprise firms create the change they wish to see in the world by strategically gathering their people.
Our focus is on making your online community the best it can be. We understand the uniqueness of your community.
We help you engage, retain, and monetize your biggest fans and most sought-after prospects with a community experience they’ll love.
We develop communities for organizations wishing to facilitate member interaction by creating a network.
Sharehold helps organizations undertake self-sustaining transformation for, with, and by their people.
Creating online communities that strengthen relationships and optimize how you connect, communicate and collaborate with your employees, customers and partners.
Helping great brands use powerful psychology to better engage their members and get visible results from their community.
Empowering businesses to build thriving online communities that put their customers at the centre of everything they do.
Building & Managing Online Communities to help Marketing & Sales Teams increase results.
Partnering with Australia’s leading brands for success in social media, community management, strategy, training, out-of-hours support and more.


The Raiden Network is an off-chain scaling solution for performing ERC20-compliant
token transfers on the Ethereum blockchain. It is Ethereum's version of
Bitcoin's Lightning Network, enabling near-instant, low-fee, scalable, and privacy-preserving payments.
The Raiden Network allows secure transfers of tokens between participants without the need for global consensus.
This is achieved using digitally signed and hash-locked transfers, called balance proofs,
fully collateralized by previously setup on-chain deposits.
Payment channels allow for practically unlimited, bidirectional transfers between two participants,
as long as the net sum of their transfers does not exceed the deposited tokens
These transfers can be performed instantaneously and without any involvement of the actual blockchain itself,
except for an initial one-time on-chain creation and an eventual closing of the channel.


(via Understanding Your Partner’s Attachment Style: An Interview with Stan Tatkin)
A great conversation about attachment styles. Awareness is power.
(via Understanding Your Partner’s Attachment Style: An Interview with Stan Tatkin)
A great conversation about attachment styles. Awareness is power.
Headphones required.
Wonder Woman (2017) dir. Patty Jenkins
literally


Please save your titles first then review it and if you feel it's complete publish it to marketplace.


Meet unique_ptr<Team> m_OurTeam!
Michael Conard
Michigan Technological University, studying Ph.D
IBM Cloud and Cognitive
Sr. Back-End Developer Intern
Nicholas Hamilton
Michigan Technological University
IBM Cloud and Cognitive
Full Stack Developer Intern
Ping Lin
Georgia Institute of Technology, studying Masters
IBM Cloud and Cognitive
Sr. Back-End Developer Intern


Pairing has been an interesting experience thus far - as part of DBC's program, students have been given the assignment to team up in teams of two approximately twice a week. The team is to practice honesty, teamwork, cooperation, and feedback to complete coding challenges. There are two roles that the pair participants must each fulfill for a fair amount of time, the Driver and the Navigator. This is similar to going on a road trip, except the code is road. Essentially, the Navigator tells the their partner what line to write what code on, while the Driver types out the code.
There have been some instances in which individuals get stuck because their idea of how to go about solving the problem is different from their partner's. Other times, individuals have very different styles of communication and they need to figure out how to not get caught up on unimportant matters. On the other hand, there are pairing soul-mates that bounce ideas off one-another, learning new tricks along the way, and just work together as an incredibly well-oiled machine.
Altogether, this hasn't been the easiest task in the world, but I think that is why this is beneficial - we'll have to deal with people who will always believe that their way is correct, without ever listening to their peer's input. Learning how to cooperate with peers in any situation is going to be a powerful tool for us, all throughout life. Also, being able to take feedback from our peers here, opens up our eyes to the habits (good and bad) that we do, whether or not we realize they exist.


Samsung Heavy Industries to pay $75 million to resolve foreign bribery case -U.S.
by ReutersWASHINGTON — Samsung heavy industries Co Ltd has agreed to pay more than $75 million in criminal penalties to resolve a U.S. investigation of a scheme to pay millions of dollars in bribes to officials in Brazil, the U.S. Justice Department said on Friday.
Samsung Heavy has admitted to paying about $20 million to a Brazilian intermediary between 2007 and 2013 knowing that parts of it would be paid as bribes to officials in Brazil’s state-run oil company Petrobras SA for a contract which facilitated the sale of a drill ship by Samsung Heavy, the Justice Department said in a statement.
Samsung Heavy will pay at least half of the total fine to the U.S. government under a deferred prosecution agreement filed in the Eastern District of Virginia, it said. (Reporting by Mohammad Zargham; Editing by Sandra Maler)


Common structures used by multiple elements. More...
Modules | |
| Transport Module. | |
| Built in and user defined transport layer implementations. | |
Classes | |
| class | Log |
| Logging utilities. More... | |
| struct | CacheChange_t |
| Structure CacheChange_t, contains information on a specific CacheChange. More... | |
| class | FragmentNumberSet_t |
| Structure FragmentNumberSet_t, contains a group of fragmentnumbers. More... | |
| struct | GuidPrefix_t |
| Structure GuidPrefix_t, Guid Prefix of GUID_t. More... | |
| struct | EntityId_t |
| Structure EntityId_t, entity id part of GUID_t. More... | |
| struct | GUID_t |
| Structure GUID_t, entity identifier, unique in DDS-RTPS Domain. More... | |
| struct | InstanceHandle_t |
| Struct InstanceHandle_t, used to contain the key for WITH_KEY topics. More... | |
| class | Locator_t |
| Class Locator_t, uniquely identifies a communication channel for a particular transport. More... | |
| class | LocatorList_t |
| Class LocatorList_t, a Locator_t vector that doesn't avoid duplicates. More... | |
| class | MatchingInfo |
| Class MatchingInfo contains information about the matching between two endpoints. More... | |
| class | SampleIdentity |
| This class is used to specify a sample. More... | |
| struct | SequenceNumber_t |
| Structure SequenceNumber_t, different for each change in the same writer. More... | |
| class | SequenceNumberSet_t |
| Structure SequenceNumberSet_t, contains a group of sequencenumbers. More... | |
| struct | SerializedPayload_t |
| Structure SerializedPayload_t. More... | |
| struct | Time_t |
| Structure Time_t, used to describe times. More... | |
| class | WriteParams |
| This class contains additional information of a CacheChange. More... | |
| class | Endpoint |
| Class Endpoint, all entities of the RTPS network derive from this class. More... | |
| class | CacheChangePool |
| Class CacheChangePool, used by the HistoryCache to pre-reserve a number of CacheChange_t to avoid dynamically reserving memory in the middle of execution loops. More... | |
| class | History |
| Class History, container of the different CacheChanges and the methods to access them. More... | |
| class | AsyncWriterThread |
| This static class owns a thread that manages asynchronous writes. More... | |
Typedefs | |
| typedef enum eprosima::fastrtps::rtps::ReliabilityKind_t | ReliabilityKind_t |
| Reliability enum used for internal purposes. More... | |
| typedef enum eprosima::fastrtps::rtps::DurabilityKind_t | DurabilityKind_t |
| Durability kind. More... | |
| typedef enum eprosima::fastrtps::rtps::EndpointKind_t | EndpointKind_t |
| Endpoint kind. More... | |
Enumerations | |
| enum | Endianness_t { BIGEND = 0x1, LITTLEEND = 0x0 } |
| This enumeration represents endianness types. More... | |
| enum | ReliabilityKind_t { RELIABLE, BEST_EFFORT } |
| Reliability enum used for internal purposes. More... | |
| enum | DurabilityKind_t { VOLATILE, TRANSIENT_LOCAL } |
| Durability kind. More... | |
| enum | EndpointKind_t { READER, WRITER } |
| Endpoint kind. More... | |
| enum | ChangeKind_t { ALIVE, NOT_ALIVE_DISPOSED, NOT_ALIVE_UNREGISTERED, NOT_ALIVE_DISPOSED_UNREGISTERED } |
| , different types of CacheChange_t. More... | |
| enum | MatchingStatus { MATCHED_MATCHING, REMOVED_MATCHING } |
| , indicates whether the matched publication/subscription method of the PublisherListener or SubscriberListener has been called for a matching or a removal of a remote endpoint. More... | |
Common structures used by multiple elements.
Durability kind.
| typedef enum eprosima::fastrtps::rtps::EndpointKind_t EndpointKind_t |
Endpoint kind.
Reliability enum used for internal purposes.
| enum ChangeKind_t |
, different types of CacheChange_t.
| Enumerator | |
|---|---|
| ALIVE | ALIVE. |
| NOT_ALIVE_DISPOSED | NOT_ALIVE_DISPOSED. |
| NOT_ALIVE_UNREGISTERED | NOT_ALIVE_UNREGISTERED. |
| NOT_ALIVE_DISPOSED_UNREGISTERED | NOT_ALIVE_DISPOSED_UNREGISTERED. |
| enum DurabilityKind_t |
| enum Endianness_t |
| enum EndpointKind_t |
Endpoint kind.
| Enumerator | |
|---|---|
| READER | |
| WRITER |
| enum MatchingStatus |
, indicates whether the matched publication/subscription method of the PublisherListener or SubscriberListener has been called for a matching or a removal of a remote endpoint.
| Enumerator | |
|---|---|
| MATCHED_MATCHING | MATCHED_MATCHING, new publisher/subscriber found. |
| REMOVED_MATCHING | REMOVED_MATCHING, publisher/subscriber removed. |
| enum ReliabilityKind_t |


In this tutorial you'll get a full tour of setting up Keptn for multi-stage progressive delivery for a node-js based microservice application.
The tutorial also gives you insights into load test automation and extending SLIs/SLOs with Load Test specific metrics gathered through Dynatrace Calculated Metrics!
Alright - here is the complete overview on what you will learn:
You can also watch a recording of an online workshop titled Setting up Event-based Progressive Delivery with Keptn on k8s
You'll find a time estimate until the end of this tutorial in the right top corner of your screen - this should give you guidance how much time is needed for each step.
Before you can get started, please make sure to have Keptn installed on your Kubernetes cluster.
If not, please follow one of these tutorials to install Keptn on your favourite Kubernetes distribution.
What you need in order to complete this tutorial is
1: keptn status needs to successfully connect to your keptn instance
2: kubectl needs to be configured to connect to your k8s cluster
3: you have access to the Keptns Bridge. If you have not yet exposed it please do so as described in Expose Keptn's Bridge
For enabling the Keptn Quality Gates and for production monitoring, we are going to use Dynatrace as the data provider. Therefore, we are going to setup Dynatrace in our Kubernetes cluster to have our sample application monitored and we can use the monitoring data for both the basis for evaluating quality gates as well as a trigger to start self-healing.
If you don't have a Dynatrace tenant yet, sign up for a free trial or a developer account.
DT_TENANT
has to be set according to the appropriate pattern:{your-environment-id}.live.dynatrace.com
{your-domain}/e/{your-environment-id}
kubectl
command itself.export DT_TENANT=yourtenant.live.dynatrace.com
export DT_API_TOKEN=yourAPItoken
export DT_PAAS_TOKEN=yourPAAStoken
If you used the variables, the next command can be copied and pasted without modifications. If you have not set the variables, please make sure to set the right values in the next command.kubectl -n keptn create secret generic dynatrace --from-literal="DT_TENANT=$DT_TENANT" --from-literal="DT_API_TOKEN=$DT_API_TOKEN" --from-literal="DT_PAAS_TOKEN=$DT_PAAS_TOKEN" --from-literal="KEPTN_API_URL=http://$(kubectl -n keptn get ingress api-keptn-ingress -ojsonpath='{.spec.rules[0].host}')/api" --from-literal="KEPTN_API_TOKEN=$(kubectl get secret keptn-api-token -n keptn -ojsonpath='{.data.keptn-api-token}' | base64 --decode)" --from-literal="KEPTN_BRIDGE_URL=http://$(kubectl -n keptn get ingress api-keptn-ingress -ojsonpath='{.spec.rules[0].host}')/bridge"
To make the tutorial experience as smooth as possible, we are providing an automation script to setup the Dynatrace OneAgent operator in your Kubernetes cluster. For details on the installation, we refer to the official Dynatrace documentation. You can download and run the script using the following instructions.
curl -o deploy-dynatrace-oneagent.sh https://raw.githubusercontent.com/keptn/examples/release-0.7.0/dynatrace-oneagent/deploy-dynatrace-oneagent.sh
chmod
command.chmod +x deploy-dynatrace-oneagent.sh
./deploy-dynatrace-oneagent.sh
kubectl get pods -n dynatrace
dynatrace-oneagent-operator-696fd89b76-n9d9n 1/1 Running 0 6m26s
dynatrace-oneagent-webhook-78b6d99c85-h9759 2/2 Running 0 6m25s
oneagent-g9m42 1/1 Running 0 69s
kubectl apply -f https://raw.githubusercontent.com/keptn-contrib/dynatrace-service/0.8.0/deploy/service.yaml
keptn configure monitoring dynatrace
Output should be similar to this:ID of Keptn context: 79f19c36-b718-4bb6-88d5-cb79f163289b
Configuring Dynatrace monitoring
Dynatrace OneAgent Operator is installed on cluster
Setting up auto-tagging rules in Dynatrace Tenant
Tagging rule keptn_service already exists
Tagging rule keptn_stage already exists
Tagging rule keptn_project already exists
Tagging rule keptn_deployment already exists
Setting up problem notifications in Dynatrace Tenant
Checking Keptn alerting profile availability
Keptn alerting profile available
Dynatrace Monitoring setup done
Verify Dynatrace configuration
Since Keptn has configured your Dynatrace tenant, let us take a look what has be done for you:
Follow the next steps only if your Dynatrace OneAgent does not work properly.
kubectl get pods -n dynatrace
might look as follows:NAME READY STATUS RESTARTS AGE
dynatrace-oneagent-operator-7f477bf78d-dgwb6 1/1 Running 0 8m21s
oneagent-b22m4 0/1 Error 6 8m15s
oneagent-k7jn6 0/1 CrashLoopBackOff 6 8m15s
env:
- name: ONEAGENT_ENABLE_VOLUME_STORAGE
value: "true"
kubectl edit oneagent -n dynatrace
At the end of your installation, please verify that all Dynatrace resources are in a Ready and Running status by executing kubectl get pods -n dynatrace
:
NAME READY STATUS RESTARTS AGE
dynatrace-oneagent-operator-7f477bf78d-dgwb6 1/1 Running 0 8m21s
oneagent-b22m4 1/1 Running 0 8m21s
oneagent-k7jn6 1/1 Running 0 8m21s
A project in Keptn is the logical unit that can hold multiple (micro)services. Therefore, it is the starting point for each Keptn installation.
To get all files you need for this tutorial, please clone the example repo to your local machine.
git clone --branch release-0.7.0 https://github.com/keptn/examples.git --single-branch
cd examples/simplenodeservice
Create a new project for your services using the keptn create project
command. In this example, the project is called simplenodeproject. Before executing the following command, make sure you are in the examples/simplenodeservice/keptn
folder.
Please note that defining a Git upstream is recommended, but in case that is not wanted the parameters git-user
, git-token
and git-remote-url
can be omitted.
keptn create project simplenodeproject --shipyard=./shipyard.yaml --git-user=GIT_USER --git-token=GIT_TOKEN --git-remote-url=GIT_REMOTE_URL
For creating the project, the tutorial relies on a shipyard.yaml
file as shown below:
stages:
- name: "staging"
deployment_strategy: "direct"
test_strategy: "performance"
- name: "prod"
deployment_strategy: "blue_green_service"
test_strategy: "performance"
This shipyard contains two stages: staging, and prod. This results in the three Kubernetes namespaces: simplenodeproject-staging, and simplenodeproject-prod.
After creating the project, services can be onboarded to our project.
keptn onboard service simplenode --project=simplenodeproject --chart=./carts
We have passed a helm charts directory to onboard service. Keptn will use this Helm Chart for its delivery. It will also automatically create the respective deployments for our blue/green and direct deployment strategies in staging and prod. There is nothing we have to worry about
After onboarding our service we can immediately start using Keptn to deploy an artifact.
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=1.0.0
Keptn will now start deploying version 1.0.0 into staging. During the first deployment some special initial steps are performed, e.g: namespaces get created for each stage.
But - as we haven't yet uploaded tests and not specified SLI/SLOs for the Quality Gates Keptn will skip these checks and promote the artifact rather quickly into production. Overall that process should not take longer than 2-3 minutes
kubectl get pods --all-namespaces | grep simplenode
simplenodeproject-prod simplenode-54d9b6775-4hlwn 1/1 Running 0 12m
simplenodeproject-staging simplenode-54d9b6775-rm8rw 1/1 Running 0 12m
After every deployment we can start in the Keptn's bridge to validate the progress. We can answer questions like
The bridge also gives you access to the links of the deployed service.
If you click on them you should see a new browser window pop open showing you version 1 in staging and version 1 in production:
Once Keptn has deployed our application and we have successfully validated that the app is indeed running by accessing the app through its URL we can also validate that Dynatrace is monitoring not only your k8s cluster but also the app we have deployed.
In Dynatrace use the navigation menu on the left and navigate to the Host view. You should find an entry for each of your k8s cluster nodes. Click one of them. You should see host metrics, list of processes & containers, events ...
Via the ...
button you can access the Smartscape view which gives you full stack visiblity of everything that is hosted on that k8s cluster node. You should also see our deployed Node.js services which you can click on and navigate to the detailed view:
If you navigate to the service view you will notice that the service has 4 tags on it: keptn_project, keptn_stage, keptn_service and keptn_deployment. These tags are extracted from the Helm Chart which is passing this information via DT_CUSTOM_PROP. These tags also later allow Keptn to query data exactly for a specific deployed service, e.g: only data from our service deployed in staging!
During the evaluation of a quality gate, the Dynatrace SLI provider is required that is implemented by an internal Keptn service, the dynatrace-sli-service. This service will fetch the values for the SLIs that are referenced in an SLO configuration.
kubectl apply -f https://raw.githubusercontent.com/keptn-contrib/dynatrace-sli-service/0.5.0/deploy/service.yaml
Configure the already onboarded project with the new SLI provider:
keptn configure monitoring dynatrace --project=simplenodeproject
Keptn Quality Gates are based on the concepts of
In Keptn we therefore need to provide an sli.yaml
that defines how to query certain metrics from a specific tool, e.g: Dynatrace. We also need to provide an slo.yaml
that defines the conditions - this file is tool independant.
To learn more about the sli.yaml and slo.yaml files, go to Specifications for Site Reliability Engineering with Keptn.
Our example comes with a basic and an extended set of SLIs and SLOs. In this step we focus on the basic version.
We have to upload two files using the add-resource command.
Ensure you navigate to the examples/simplenode/keptn
folder.
dynatrace/sli_basic.yaml
as dynatrace/sli.yaml
!keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=dynatrace/sli_basic.yaml --resourceUri=dynatrace/sli.yaml
This Dynatrace specific SLI contains the definition of 5 indicators. Each indicator has a logical name, e.g: throughput and the tool specific query, e.g: Dynatrace Metrics Query. You can also see that the query definition can leverage placeholders such as $PROJECT, $SERVICE, $STAGE ... - this is great as we can use them to filter on exactly those services managed by Keptn as long as these tags are put on the Dynatrace entities:
---
spec_version: '1.0'
indicators:
throughput: "metricSelector=builtin:service.requestCount.total:merge(0):sum&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
error_rate: "metricSelector=builtin:service.errors.total.rate:merge(0):avg&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
response_time_p50: "metricSelector=builtin:service.response.time:merge(0):percentile(50)&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
response_time_p90: "metricSelector=builtin:service.response.time:merge(0):percentile(90)&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
response_time_p95: "metricSelector=builtin:service.response.time:merge(0):percentile(95)&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
slo_basic.yaml
as slo.yaml
keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=slo_basic.yaml --resourceUri=slo.yaml
This slo.yaml
defines the objectives and references the SLIs defined in the sli.yaml
:
---
spec_version: '0.1.0'
comparison:
compare_with: "single_result"
include_result_with_score: "pass"
aggregate_function: avg
objectives:
- sli: response_time_p95
pass: # pass if (relative change <= 10% AND absolute value is < 500)
- criteria:
- "<=+10%" # relative values require a prefixed sign (plus or minus)
- "<600" # absolute values only require a logical operator
warning: # if the response time is below 800ms, the result should be a warning
- criteria:
- "<=800"
- sli: throughput
pass:
- criteria:
- ">4000"
- sli: error_rate
weight: 2
pass:
- criteria:
- "<=1%"
warning:
- criteria:
- "<=2%"
- sli: response_time_p50
- sli: response_time_p90
pass:
- criteria:
- "<=+10%"
warning:
- criteria:
- "<=+10%"
total_score:
pass: "90%"
warning: "75%"
Uploading SLIs & SLOs alone is not enough. What we need are some tests, e.g: simple API performance tests that get executed by Keptn. After those tests are executed Keptn will evaluate the SLIs/SLOs for the timeframe of the test execution.
Keptn comes with a JMeter-Service that can execute JMeter tests when a new deployment happened. In our tutorial we are however using the JMeter-Extended-Service as it gives us some more flexibilty with different workloads.
kubectl -n keptn set image deployment/jmeter-service jmeter-service=keptncontrib/jmeter-extended-service:0.1.0
Now we are ready to upload a test script and workload configuration for our staging stage. Ensure you navigate to the examples/simplenode/keptn
folder.
keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=jmeter/load.jmx --resourceUri=jmeter/load.jmx
keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=jmeter/jmeter.conf.yaml --resourceUri=jmeter/jmeter.conf.yaml
As we have now uploaded tests, SLIs & SLOs we can run the same artifact of version 1.0.0 through the delivery pipeline. The difference now is that Keptn will automatically execute tests in staging and then evaluates our indicators (specified in SLI.yaml) against our objectives (specified in SLO.yaml) for the timeframe of the test execution.
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=1.0.0
Remember - this time the deployment will take a bit longer as the tests take about 2-3 minutes to run before Keptn can pull in metrics from Dynatrace. Overall a deployment will now take about 5 minutes. Go back to the Keptn's Bridge and watch for the new events coming in. In a couple of minutes you will also see the evaluation results of your Quality Gate. Lets hope all is green and the build makes it all the way into production :-)
So far we have uploaded our test script, test workload and our SLI & SLO for our staging stage.
If we also want a quality gate to be enforced after a blue/green deployment is done to production to validate if the production deployment is good enough or whether the Blue/Green deployment should be reverted back we have to add SLI.yaml, SLO.yaml and our tests for production as well.
dynatrace/sli_basic.yaml
as dynatrace/sli.yaml
for prod!We could upload a different sli.yaml for production than the one we have for staging. In a real scenario you probably want this as you may want to include additonal indicators from other parts of the infrastructure that you didnt have available in staging. For our sample we just use the same sli_basic.yaml
!
keptn add-resource --project=simplenodeproject --stage=prod --service=simplenode --resource=dynatrace/sli_basic.yaml --resourceUri=dynatrace/sli.yaml
If you wonder - how can the same SLI be working in production? Well - its because the SLI is leveraging the placeholders such as $STAGE. Once Keptn will evaluate the SLIs for production this value will be replaced with prod
. And - as long as all services are correctly tagged in Dynatrace with e.g: keptn_stage:prod
we are all good.
Here is one of the indicator definitions of this SLI file so you see what I mean:
indicators:
throughput: "metricSelector=builtin:service.requestCount.total:merge(0):sum&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
slo_basic.yaml
as slo.yaml
Same as with the SLI. We could upload a different SLO that includes different objectives for production, e.g: you may expect different load behavior or you have different hardware your system runs on. In that case you would adjust the SLOs to reflect what you expect in production. For our sample we just take the same SLO that we used for staging
keptn add-resource --project=simplenodeproject --stage=prod --service=simplenode --resource=slo_basic.yaml --resourceUri=slo.yaml
In order for the quality gates to evaluate a representative timeframe with representative load we will upload tests to production. This will make sure that after Keptn deploys the artifact in production that these tests get executed against the new Blue/Green deployment. After that the quality gate kicks in. If the validation succeeds Keptn will keep the new build - otherwise it will roll back.
We will use the same test scripts as in staging. We could use different tests - but - for our example thats good enough!
keptn add-resource --project=simplenodeproject --stage=prod --service=simplenode --resource=jmeter/load.jmx --resourceUri=jmeter/load.jmx
keptn add-resource --project=simplenodeproject --stage=prod --service=simplenode --resource=jmeter/jmeter.conf.yaml --resourceUri=jmeter/jmeter.conf.yaml
In the last steps we finished setting up tests and quality gates for both staging and production.
Now its time to put this to the test. If you remember - the samplenodeservice app comes with 4 different builds. Every build has a unique characteristic, e.g: some builds are good all the way to production, some builds have a high failure rate and should be stopped by the stagging quality gate, some builds are only problematic in production and should therefore be rolled back during a blue/green validation phase.
Here is what we are going to do in this step. We are going to deploy build 2, 3 and then 4 and validate if Keptn catches all problems as highlighted in the next image:
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=2.0.0
Watch the bridge and see if build 2.0.0 is stopped by the quality gate. It should - as build 2.0.0 has a high failure rate which is detected by the SLI error_rate!
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=3.0.0
Watch the bridge and see if build 3.0.0 makes it all the way to production and stays there. It should - as build 3.0.0 has no high failure rate any longer and also doesnt show any other signs of problems. As we have production quality gates enabled as well you should also see tests being executed in production followed by quality gate evaluation.
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=4.0.0
Watch the bridge and see if build 4.0.0 makes it all the way to production and is then rejected and rolled back to build 3.0.0. Build 4 should pass the quality gate in staging as the problem that is built into 4.0.0 only shows up in production. This is why you should see the build being promoted in production. But - after the tests are executed and evaluation fails Keptn will automatically roll it back to Build 3 in production. You can also validate this by browsing to your app
Our quality gates so far are based on 5 basic metrics: throughput, error rate, response time (p50, p90, p95).
While this is a great start we can do much more!!
Dynatrace gives us the option to extract context information from requests that are executed by test tools. Such context information could be the Test Script Name (load.jmx), Test Scenario Name (fullscenario), Test Step Name (homepage, echo, invoke, version). This information can be passed by the Test Tool using an HTTP Header that can be analyzed by Dynatrace as requests come in. Here is such an example header
X-Dynatrace-Test: LTN=performance_build1;LSN=Test Scenario;TSN=homepage;
The JMeter test file we uploaded - load.jmx
has already been adjusted so that it sends these HTTP Headers including information such as Test Step Name (TSN) for every of the 4 test steps it executes: homepage, version, api, invoke
If we want to extend our SLIs with metrics such as "Response Time for Invoke", "Response Time for Homepage" or "Number of backend microservice calls for Invoke" ... we need to do two things
1: Create Request Attributes that tell Dynatrace to extract these HTTP Header values
2: Create Calculated Service Metrics that will give us new metrics split by Test Name
The following image shows how this all plays together:
Good news is that we can fully automate the configuration of Request Attributes and Calculated Service Metrics through the Dynatrace API. We have two scripts that does this for us. Please make sure you navigate into the examples\simplenodeservice\dynatrace folder. Here we execute the following scripts:
./createTestRequestAttributes.sh
./createTestStepCalculatedMetrics.sh CONTEXTLESS keptn_project
The first script will create but not overwrite the Request Attribute rules for TSN (Test Step Name), LTN (Load Test Name) & LSN (Load Script Name)
The second script will create but not overwrite the following Calculated Service Metrics:
Test Step Response Time | calc:service.teststepresponsetime |
Test Step Service Calls | calc:service.teststepservicecalls |
Test Step DB Calls | calc:service.teststepdbcalls |
Test Step Failure Rate | calc:service.teststepfailurerate |
Test Requests by HTTP Status | calc:service.testrequestsbyhttpstatus |
Test Step CPU | calc:service.teststepcpu |
Test Step DB Calls | calc:service.teststepdbcalls |
From now on - everytime Keptn executes these JMeter tests we will have new metrics available that provide a data dimension for each Test Step Name.
This also allows us to extend our SLIs with these metric definitions. In our examples we therefore have a sli_perftest.yaml
and also a slo_perftest.yaml
that include these new metrics.
Make sure you navigate to the examples\simplenodeservice\keptn directory. Now:
dynatrace/sli_perftest.yaml
as dynatrace/sli.yaml
for staging!We could upload these new sli files with the extended indicators to both staging and production. But - in order to show you that we can have different SLIs and SLOs in each stage we just upload it to staging.
keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=dynatrace/sli_perftest.yaml --resourceUri=dynatrace/sli.yaml
Please explore the sli_perftest.yaml file yourself to see the new queries. For reference here are two of the queries that show you how the Dynatrace Metrics API allows us to query calculated service metrics for individual dimensions (e.g: Test Name):
rt_test_version: "metricSelector=calc:service.teststepresponsetime:filter(eq(Test Step,version)):merge(0):avg&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
rt_test_homepage: "metricSelector=calc:service.teststepresponsetime:filter(eq(Test Step,homepage)):merge(0):avg&entitySelector=tag(keptn_project:$PROJECT),tag(keptn_stage:$STAGE),tag(keptn_service:$SERVICE),tag(keptn_deployment:$DEPLOYMENT),type(SERVICE)"
slo_perftest.yaml
as slo.yaml
Same as with the SLI. We just upload it to the staging as this file now defines objectives for the new indicators defined in the SLI.
keptn add-resource --project=simplenodeproject --stage=staging --service=simplenode --resource=slo_perftest.yaml --resourceUri=slo.yaml
Let's go back to build 1.0.0 and deploy it again. What we should see is that Keptn will query all these additional test step specific metrics for the quality gate evaluation in staging.
keptn send event new-artifact --project=simplenodeproject --service=simplenode --image=grabnerandi/simplenodeservice --tag=1.0.0
What you should see are all these new SLIs showing up in the bridge!
While it is great that Keptn pulls in all these metrics automatically for us and evaluates them as part of the quality gate - some of us might still want to look at a dashboard - seeing all metrics in real-time while tests are running. Or maybe going back in time and explore the details of a test that ran in the past.
Dynatrace provides an automation API to create dashboards, allowing us to create a dashboard that shows all key metrics of our application in a single view.
Make sure you navigate to the folder examples\simplenodeservice\dynatrace. Now execute this
$ ./createLoadTestingDashboard.sh
This script will create a new dashboard in Dynatrace called "Keptn Performance as a Self-Service Insights Dashboard".  It should look somewhat like this!
Thanks for taking a full tour through Keptn!
Although Keptn has even more to offer that should have given you a good overview what you can do with Keptn.
You should have been able to achieve exactly what is shown in the following animated gif!
If you have more questions you can also watch a recording of an online workshop titled Setting up Event-based Progressive Delivery with Keptn on k8s
Keptn can be easily extended with external tools such as notification tools, other SLI providers, bots to interact with Keptn, etc.
While we do not cover additional integrations in this tutorial, please feel fee to take a look at our integration repositories:
Please visit us in our Keptn Slack and tell us how you like Keptn and this tutorial! We are happy to hear your thoughts & suggestions!
Also, make sure to follow us on Twitter to get the latest news on Keptn, our tutorials and newest releases!