Presented by Mike Smith, University of Sheffield
michaeltsmith.org.uk
<EMAIL_ADDRESS>@mikethomassmith
We take an image and add some carefully crafted noise.
Add the gradient (L-BFGS)
Note: Noise image scaled by 10x. Dog becomes ostrich
Szegedy, et al. 2014 (original paper describing AS in DNNs)
Maximally perturb the feature (pixel) with greatest gradient (wrt class) [Papernot, 2016].
They find they modify about 4% of pixels in MNIST to produce an Adversarial Sample.
Moosavi-Dezfooli, 2016
Evtimov, 2017 (published?)
Various ideas:
Note that I only use the posterior mean and not the posterior variance to determine if something is confidently classified.
Note: Placed confidence thresholds using data - so 90% of training data lies between boundaries. This allows us to control for the lengthscale etc of the classifier.
Needed a modified attack to reach threshold.
Reach 95th-percentileResponse to lengthscale
Could it be applied to deep GPs?
Other kernels?
Optimise + how to get to higher dimensions?
This tool works by combining several tricks for tightening the bounds, lots more probably exist.
Thanks
Szegedy, Christian, et al. "Intriguing properties of neural networks." arXiv preprint arXiv:1312.6199 (2013).
Nguyen, Anh, Jason Yosinski, and Jeff Clune. "Deep neural networks are easily fooled: High confidence predictions for unrecognizable images." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2015.
Fischer, Volker, et al. "Adversarial Samples for Semantic Image Segmentation." arXiv preprint arXiv:1703.01101 (2017).
Goodfellow, Ian J., Jonathon Shlens, and Christian Szegedy. "Explaining and harnessing adversarial samples." arXiv preprint arXiv:1412.6572 (2014).
Fawzi, Alhussein, Omar Fawzi, and Pascal Frossard. "Analysis of classifiers' robustness to adversarial perturbations." arXiv preprint arXiv:1502.02590 (2015).
Tabacof, Pedro, and Eduardo Valle. "Exploring the space of adversarial images." Neural Networks (IJCNN), 2016 International Joint Conference on. IEEE, 2016.
Papernot, Nicolas, Patrick McDaniel, and Ian Goodfellow. "Transferability in machine learning: from phenomena to black-box attacks using adversarial samples." arXiv preprint arXiv:1605.07277 (2016).
Moosavi-Dezfooli, Seyed-Mohsen, et al. "Universal adversarial perturbations." arXiv preprint arXiv:1610.08401 (2016).
Alexey, Goodfellow, and Bengio. "Adversarial samples in the physical world." arXiv preprint arXiv:1607.02533 (2016).
Evtimov, Ivan, et al. "Robust physical-world attacks on machine learning models." arXiv preprint arXiv:1707.08945 (2017).
Papernot, Nicolas, et al. "The limitations of deep learning in adversarial settings." Security and Privacy (EuroS&P), 2016 IEEE European Symposium on. IEEE, 2016b.
Papernot, Nicolas, et al. "Practical black-box attacks against machine learning." Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security. ACM, 2017.
Carlini, Nicholas, and David Wagner. "Towards evaluating the robustness of neural networks." Security and Privacy (SP), 2017 IEEE Symposium on. IEEE, 2017.
Su, Jiawei, Danilo Vasconcellos Vargas, and Sakurai Kouichi. "One pixel attack for fooling deep neural networks." arXiv preprint arXiv:1710.08864 (2017).
L. Huang, A. D. Joseph, B. Nelson, B. I. P. Rubinstein, and J. D. Tygar, “Adversarial machine learning,” in Proceedings of the 4th ACM Workshop on Security and Artificial Intelligence, AISec 2011, Chicago, IL, USA, October 21, 2011, 2011, pp. 43–58. [Online]. Available: http://doi.acm.org/10.1145/2046684.2046692
K. Grosse, P. Manoharan, N. Papernot, M. Backes, and P. McDaniel, “On the (Statistical) Detection of Adversarial Examples,” ArXiv e-prints, Feb. 2017
J. Bradshaw, A. G. d. G. Matthews, and Z. Ghahramani, “Adversar- ial Examples, Uncertainty, and Transfer Testing Robustness in Gaussian Process Hybrid Deep Networks,” ArXiv e-prints, Jul. 2017.
F. Zhang, P. Chan, B. Biggio, D. Yeung, and F. Roli, “Adversarial fea- ture selection against evasion attacks,” IEEE Transactions on Cybernetics, vol. 46, pp. 766–777, 2016.
W. Xu, D. Evans, and Y. Qi, “Feature Squeezing: Detecting Adversarial Examples in Deep Neural Networks,” ArXiv e-prints, Apr. 2017.
G. K. Dziugaite, Z. Ghahramani, and D. M. Roy, “A study of the effect of jpg compression on adversarial images,” arXiv preprint arXiv:1608.00853, 2016.


This assistant helps with issues regarding Heiconf and Webex.
First, choose the platform you're having issues with:
Heiconf
Cisco Webex


{% extends 'portal/base.html' %} {% load static %} {% load election_extra %} {% block title %}Elections - ECSS{% endblock %} {% block portalcontent %} {{ nomination.position.election.name }} Nomination ends on {{ nomination.position.election.nomination_end|date }} {{ nomination.position.election.nomination_end|time:"H:i" }}. {% if nomination|is_supporting:user %} You have already supported {{ nomination.name }} for {{ nomination.position.name }} in {{ nomination.position.election.name }}. {% else %} {% csrf_token %} Do you want to support {{ nomination.name }} for {{ nomination.position.name }} in {{ nomination.position.election.name }}? {% if supporting_name %} You will no longer be supporting {{ supporting_name }} for {{ nomination.position.name }} in {{ nomination.position.election.name }}. {% else %} You are currently supporting no one for {{ nomination.position.name }} in {{ nomination.position.election.name }}. {% endif %} You are able to support one nomination for each role and you can change your support before nomination closes. {% endif %} {{ nomination.position.election.name }} {% endblock %}
You have already supported {{ nomination.name }} for {{ nomination.position.name }} in {{ nomination.position.election.name }}.
You are able to support one nomination for each role and you can change your support before nomination closes.


Make sure we don't reload a <video> element after a dialog is shown.
Test this by loading a movie slowly and showing a dialog when a 'loadstart' event
handler is called. If the movie is reloaded when the dialog is "dismissed", another
'loadstart' event will be fired


A base LFS system can be used as a development platform, however the base system only includes language support for C, C++ and Perl. This chapter provides instructions to build many popular programming environments to greatly expand your system's development capabilities.


Joe in College ---^
Hello I'm Joe and I love Cheetos! I live in my moms Basement and make this website to help make the world a better place. I am 28 and live in Massachusetts and a graduate from Wohescer Community College. I was born in 1992 in Nashville Illinois. I attended Nashville High School where I graduated with a 2.5 GPA. I used to work for Cheetos before I got fired for hacking into the mainframe to get a coupon code that would let me eat Cheetos for free. I currently reside in my mom’s basement and make this awesome website.


Sharp Enough to See Through Color Oct 29
(from Chapman, F)
The blue feathers in most birds don't actually have any blue pigment. The particular pattern of pores in the feather's structure scatter certain wavelengths of light so that it appears that they are colored.
In other words, it's a physical (structural) effect, not a chemical one. There isn't actually any blue in a kingfisher's feather.
The man that instigated the scientific investigation of this topic was ornithologist, Louis Agassiz Fuertes. His bird observations are famous:
He made thousands of bird paintings and sketches, based on studies in nature and details from fresh specimens, that illustrate a range of ornithological works.
As the sketches above show, he could draw complex bird behavior from memory.
Awesome to consider how sharply Agassiz managed to hone his skills of observation.


MERS-CoV OpenUrl dromedary East Middle studies dromedaries infection seroprevalence coronavirus RNA respiratory prevalence syndrome camels Emerging shedding CrossRef populations Diseases. Infectious human Respiratory study Syndrome antibodies MERS transmission Coronavirus animals conducted higher viral (MERS-CoV) Africa Saudi age vaccination Euro Surveill. camel population Available Dromedary Perera measured potential results Health. Reusken World [Accessed calculated data from: Chu December United active antibody available calves country high likely linked search used Camel Corman KSA Meyer camels, countries epidemiologically review sampled samples systematic tested using virus (%) Arab Arabian Burkina Egypt Evidence Infection Table Web [Internet]. dromedaries, infected infection. longitudinal measures sample seropositivity size Arabia. Eltahir Ethiopia, Health Kenya OIE Raj Science View animal appears calving camels. compared contact disaggregated evidence given infectious juveniles markets prior reported response sampling strategy sub-national vaccine &; Abu Camels Camels, FAOSTAT Farag Fig Godeke Hemida However, Morocco Organisation Yusof access-date:September adult area camels: confirm criteria cross-sectional duration dynamics herds new positive positivity published reporting showed significantly similar specific stratified studies, susceptible text titres understanding vaccination. van (both *value Absence Abstract Age Animal Antibodies Arabia, Bank Chan Chen Clarivate Download Egypt, Emirates. Faso, Figure Gomaa Haagmans Hammadi Human Infections. Kenya, Microbes Muller Nigeria, Open Pas Peninsula Public RT-PCR Total Trop UAE Underlined Wang West, abattoirs adults aggregated cases country-level data-hide-link-title=""> data-icon-position="" days density detected epidemiology farms figure gaps highlights immunity imported include infections investigation isolated italicised level. livestock models months observed parenthesis. patterns peak publications. quarantine records remaining risk role seasonal seroprevalence. surface tab taken temporal trade variation zoonotic


Lua Patterns
Patterns Tutorial
lua-users home wiki
Lua patterns can match sequences of characters, where each character can be optional, or repeat multiple times. If you’re used to other languages that have regular expressions to match text, remember that Lua’s pattern matching is not the same: it’s more limited, and has different syntax.
After reading this tutorial, it’s very strongly recommended to read the manual on patterns[1], so you know everything it offers.
Introduction to patterns
First we will use the string.find function, which finds the first occurrence of a pattern in a string and returns start and end indices of the first and last characters that matched the text:
> = string.find('banana', 'an') -- find 1st occurance of 'an' (letters are matched literally)
2 3
> = string.find('banana', 'lua') -- 'lua' will not be found
nil
But literally matching text isn’t that useful, so patterns have the concept of character classes. A character class is a pattern that matches one of a set of characters. For example, . is a character class that matches any character:
> = string.find("abcdefg", 'b..')
2 4
We can now use these indices to get the matched text, but there’s a better way: the string.match function. It returns the matched text, or nil if the pattern is not found: (actually, find also returns the matched text, but it first returns the indexes; match only returns the text)
> = string.match("abcdefg", 'b..')
bcd
Patterns have a few pre-defined classes, use them as “%x”, where “x” is the letter identifying the class:
> = string.match("foo 123 bar", '%d%d%d') -- %d matches a digit
123
> = string.match("text with an Uppercase letter", '%u') -- %u matches an uppercase letter
U
Making the letter after the % uppercase inverts the class, so %D will match all non-digit characters. See the patterns manual (linked at the top of the tutorial) for a list of all pre-defined classes.
You can also create your own classes by wrapping a group of characters in square brackets. This will match one of the characters. If the first character inside the brackets is ^, then it will match a character not in the group.
> = string.match("abcd", '[bc][bc]')
bc
> = string.match("abcd", '[^ad]')
b
> = string.match("123", '[0-9]') -- you can specify a range of characters using -
1
Repetition
Even with character classes this is still very limiting, because we can only match strings with a fixed length. To solve this, patterns support these four repetition operators:
* Match the previous character (or class) zero or more times, as many times as possible.
+ Match the previous character (or class) one or more times, as many times as possible.
- Match the previous character (or class) zero or more times, as few times as possible.
? Make the previous character (or class) optional.
We’ll start with ?, since it’s the simplest:
> = string.match("examples", 'examples?')
examples
> = string.match("example", 'examples?')
example
> = string.match("example", 'examples')
nil
Now an example of +. Note how it’s used with a class, so it can match a sequence of different characters:
> = string.match("this is some text with a number 12345 in it", '%d+')
12345
Unlike +, * can match nothing:
> = string.match("one |two| three", '|.*|')
|two|
> = string.match("one || three", '|.*|')
||
> = string.match("one || three", '|.+|')
nil
A common mistake with + and * is not realizing that they match as much as possible, which may not be the desired result. One way to fix this is using -:
> = string.match("one |two| three |four| five", '|.*|')
|two| three |four|
> = string.match("one |two| three |four| five", '|.-|')
|two|
> = string.match("one |two| three |four| five", '|[^|]*|') -- another solution can be to not let the contents match the delimiter
|two|
When using -, you need to remember to “anchor” it from both sides, otherwise it will match nothing (since it tries to match as little as possible):
> = string.match("abc", 'a.*')
abc
> = string.match("abc", 'a.-') -- the .- part matches nothing
a
> = string.match("abc", 'a.-$') -- the $ matches the end of the string
abc
> = string.match("abc", '^.-b') -- the ^ matches the start of the string
ab
Here we also introduced ^ and $, which match the start and end of the string. They’re not just for use with -, you can just prepend the pattern with ^ to make it match at the start, append $ to make it match at the end, and wrap it in both (like the example above) to make it match the whole string.
Finally, you might be thinking how to match all these special characters literally. The solution is to prepend them with a % character:
> = string.match("%*^", '%%%*%^')
%*^
Captures
What if you want to get certain pieces out of a string of text? This can be done by wrapping parts of a pattern in ( ), and the contents of each of these captures will be returned from string.match.
> = string.match("foo: 123 bar: 456", '(%a+):%s*(%d+)%s+(%a+):%s*(%d+)') -- %a: letter %s: whitespace
foo 123 bar 456
Each capture is returned as a separate result, so this is useful for splitting out values
date = "04/19/64"
m, d, y = string.match(date, "(%d+)/(%d+)/(%d+)")
print("19" .. y) --> 1964
For more on captures, see the manual [2]
Limitations of Lua patterns
Especially if you’re used to other languages with regular expressions, you might expect to be able to do stuff like this:
'(foo)+' -- match the string "foo" repeated one or more times
'(foo|bar)' -- match either the string "foo" or the string "bar"
Unfortunately Lua patterns do not support this, only single characters can be repeated or chosen between, not sub-patterns or strings. The solution is to either use multiple patterns and write some custom logic, use a regular expression library like lrexlib or Lua PCRE, or use LPeg [3]. LPeg is a powerful text parsing library for Lua based on Parsing Expression Grammar [4]. It offers functions to create and combine patterns in Lua code, and also a language somewhat like Lua patterns or regular expressions to conveniently create small parsers.
See Also
Again, now that you have an idea of how patterns work, see the patterns manual[1] to find out all the possibilities. RecentChanges · preferences edit · history Last edited June 13, 2014 6:50 pm GMT (diff)
- Previous
- Next


{% extends "layout.html" %} {% block content %}
Click to view an interactive example of a PCI-compliant UI integration for online payments.
To learn more about client-side integration solutions, check out Online payments.
Drop-in
Component
Card
iDEAL


Drop image here.
RGB Analysis
Gamut.js analyses and compares images with HTML5 canvas and JavaScript.
Try it for yourself.
Why?
Gamut.js analyses and compares images with HTML5 canvas and JavaScript.
Try it for yourself.


Hello! I'm a Computer Science Major at the University of Manitoba aspiring to impact the world one day
I want to know more about youJava
C
C++
Agile development
HTML
CSS
XML
NativeScript
JavaScript
NativeScript
GitHub
processing
X Code
Android Studio
TypeScript
I hit the gym 6 times a week performing various strength and hypertrophy training
I travel every year in the summer with either my friends or family. Some of my recent trips were in Toronto, Chicago and New York with my friends
When I travel, I love to capture great moments with my camera
Check out my instagram and VSCO to see some of my work!
vsco.co/kabellanosa
@karlosa_
I love eating so much I might as well call it a hobby
Here are ways you can contact me


点击黄色区域显示其内容，也可点击此处显示全部
Jay zhou
The first personal album "Jay" was released in 2000. In 2001, the album "Fantasia" laid the fusion of Chinese and Western styles of music. In 2002, the "The One" World Tour was held
In 2005, he won the Taiwan Film Golden Horse Award and the Hongkong Film Golden Award Best Newcomer Award with the action movie "D". Since 2006, it has won the world music award three best seller in China for.
The Domsters
Jolin, his native name, Cai Yiling, of Quanzhou, Fujian Province, was born in Xinzhuang City, Taipei County, Taiwan (Xinzhu ang District, Xinzhuang District) in Taipei County, Taiwan, in September 15, 1980.
In his family, a sister and father Cai Zhuchen had been engaged in accounting work; mother H uang Chunmei was a low profile and rarely appeared in front of the media.


The Vert.x web stack provides many tools to build web application backends. This includes advanced routing, authentication, a HTTP client, and more. This chapter will guide you through exposing a HTTP API with JSON web tokens (JWT) for access control, making HTTP requests to other services, and building a reactive single-page application that connects to the HTTP API.
This book does not cover the following noteworthy elements from the Vert.x web stack that are not needed to build the application in part 2: routing with regular expressions, cookies, server-side sessions, server-side template rendering and cross-site request forgery protection. You can get more details in the official documentation at vertx.io/.
Let us start with a reminder of what the public API service does, as illustrated in figure 8.1.
This service is a edge service (or service gateway depending on how you prefer to name it) as it exposes an HTTP API, but it essentially composes functionality found in other services. In this case the user profile and activity services are being used. These 2 services are internal to the application and not publicly exposed. They also lack any form of authentication and access-control, which is something the public API cannot afford for most operations.
The following Vert.x modules are needed to implement the public API:
vertx-web
rx rpveodi dacnaved HCAZ eteqsur essocngirp inyutfaocnitl,vertx-web-client
rv seius HXYL tsuereqs re xrp xcty olpeirf cnp cvaytiti cvesesri,vertx-auth-jwt
rx eenrgeat nzu sersocp ISDG hwv esontk, cng permorf cscase-ntocolr.The complete source code of the public API service can be found in the part2-steps-challenge/public-api folder of the book source code repository.
Let us start with the Vert.x web router.
Vert.x core provides a very low-level HTTP server API, where you need to pass a request handler for all types of HTTP requests. If you just use Vert.x core, you need to manually check what is the requested path and method. This is fine for simple cases as we did in some earlier chapters, but it can be quickly complicated.
The vertx-web module provides a router that can act as a Vert.x HTTP server request handler, and manages the dispatch of HTTP requests to suitable handlers based on request paths (e.g., /foo) and HTTP methods (e.g., POST), as illustrated in figure 8.2.
Listing 8.1 shows how to initialize then set up a router as a HTTP request handler:
Router router = Router.router(vertx); // (...) #1 vertx.createHttpServer() .requestHandler(router) #2 .listen(8080);
The Router class provides a fluent API to describe routes based on HTTP methods and paths, as seen in listing 8.2.
BodyHandler bodyHandler = BodyHandler.create(); #1 router.post().handler(bodyHandler); #2 router.put().handler(bodyHandler); String prefix = "/api/v1"; router.post(prefix + "/register").handler(this::register); #3 router.post(prefix + "/token").handler(this::token); // (...) router.get(prefix + "/:username/:year/:month") #4 .handler(jwtHandler) #5 .handler(this::checkUser) .handler(this::monthlySteps); // (...)
An interesting property of the Vert.x router is that handlers can be chained. With the definitions from listing 8.2 a POST request to /api/v1/register first goes through a BodyHandler instance. This handler is useful for easily decoding a HTTP request body payload. The next handler is the register method.
We also have the definition of the route for GET requests to monthlySteps where the request first goes through jwtHandler then checkUser, as illustrated in figure 8.3. This is useful for decomposing a HTTP request processing concerns in several steps: jwtHandler checks that a valid JWT token is in the request, checkUser checks that the JWT token grants permissions to access the resource, and finally monthlySteps gives how many steps a user has done in a month.
Note that the both checkUser and jwtHandler will be detailed in the section about JWT tokens.
The io.vertx.ext.web.handler package contains useful utility handlers including BodyHandler. You will especially find handlers for HTTP authentication, CORS, CSRF, favicon, HTTP sessions, static files serving, virtual hosts and template rendering.
Let us now dive into the implementation of a handler. Since the public API service forwards requests to the user profile and activity services, we need to use the Vert.x web client. Again the Vert.x core APIs offer a low-level HTTP client, while the WebClient class from the vertx-web-client module offers a richer API.
Creating a web client instance is as simple as:
WebClient webClient = WebClient.create(vertx);
A WebClient instance is typically used a private field in a verticle, as it can be used to perform multiple concurrent HTTP requests. The whole application uses the RxJava 2 bindings, so we can take advantage of them to compose asynchronous operations. As we will see in later examples, the RxJava bindings sometime bring additional functionality for dealing with error management.
Listing 8.3 shows the implementation of the register
route handler.
private void register(RoutingContext ctx) { webClient .post(3000, "localhost", "/register") #1 .putHeader("Content-Type", "application/json") #2 .rxSendJson(ctx.getBodyAsJson()) #3 .subscribe( response -> sendStatusCode(ctx, response.statusCode()), #4 err -> sendBadGateway(ctx, err)); } private void sendStatusCode(RoutingContext ctx, int code) { ctx.response().setStatusCode(code).end(); } private void sendBadGateway(RoutingContext ctx, Throwable err) { logger.error("Woops", err); ctx.fail(502); }
This example teaches us both how to handle a HTTP request with a router, and how to use the web client. The RoutingContext class encapsulates details about the HTTP request, and provides the HTTP response object via the response method. HTTP headers can be set in both requests and responses. The response is sent once the end method has been called. A status code can be specified, although by default it will be 200 (ok). We can see that the getBodyAsJson transforms the HTTP request body to a JsonObject, while rxSendJson sends a HTTP request with a JsonObject as body. By default Vert.x Buffer objects carry bodies in both requests and responses, but there are helpers methods to convert from or to String, JsonObject and JsonArray.
Listing 8.4 offers another router handler method for HTTP GET requests to /api/v1/:username where :username is a path parameter.
private void fetchUser(RoutingContext ctx) { webClient .get(3000, "localhost", "/" + ctx.pathParam("username")) #1 .as(BodyCodec.jsonObject()) #2 .rxSend() .subscribe( resp -> forwardJsonOrStatusCode(ctx, resp), err -> sendBadGateway(ctx, err)); } private void forwardJsonOrStatusCode(RoutingContext ctx, HttpResponse<JsonObject> resp) { if (resp.statusCode() != 200) { sendStatusCode(ctx, resp.statusCode()); } else { ctx.response() .putHeader("Content-Type", "application/json") .end(resp.body().encode()); #3 } }
This example shows the as method that converts HTTP responses to another type than Buffer using a BodyCodec. We also see that the HTTP response end method can also take an argument which is the response content. It can be a String or a Buffer. While it is often the case that the response is sent in a single end method call, you can send intermediary fragments using the write method until a final end call closes the HTTP response, as in:
response.write("hello").write(" world").end();
JSON Web Tokens (JWT) is an open specification for securely transmitting JSON-encoded data between parties [JWT]. JWT tokens are signed with either a symmetric shared secret, or an asymmetric public / private key pair, so it is always possible to verify that the information that they contain has not been modified. This is very interesting as a JWT token can be used to hold claims such as identity and authorization grants. JWT tokens can be exchanged as part of HTTP requests using the Authorization HTTP header.
Let us dissect how to use JWT tokens, what data they contain, and next how to both validate and issue them with Vert.x.
JWT is only one protocol supported by Vert.x. Vert.x offers the vertx-auth-oauth2 module for OAuth2 which is a popular protocol among public service providers like Google, GitHub or Twitter. You will be interested in using it if your application needs to integrate with such service (e.g., accessing a user GMail account data), or when your application wants to expose to grant access to third-party services with OAuth2.
To illustrate that, let us interact with the public API and authenticate as user foo with password 123, and get a JWT token. Listing 8.5 shows the HTTP response.
$ http :4000/api/v1/token username=foo password=123 #1 HTTP/1.1 200 OK Content-Type: application/jwt content-length: 496 eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJkZXZpY2VJZCI6ImExYjIiLCJpYXQiOjE1NjUxNjc0NzUsImV4cCI6MTU2NTc3MjI3NSwiaXNzIjoiMTBrLXN0ZXBzLWFwaSIsInN1YiI6ImZvbyJ9.J_tn2BjMNYE6eFSHwSJ9e8DoCEUr_xMSlYAyBSy1-E_pouvDq4lp8QjG51cJoa5Gbrt1bgtDHinJsLncG1RIsGr_cz1rQw8_GlI_-GdhqFBw8dVjlsgykSf5tfaiiRwORmz7VH_AAk-935aVlxMg4mxkbOvN4YDxRLhLb4Y78TA47F__ivNsM4gLD8CHzOUmTEta_pjpZGzsErmYvzDOV6F7rOZcRhZThJxLvR3zskrtx83iaNHTwph53bkHNOQzC66wxNMar_T4HMRWzqnrr-sFIcOwLFsWJKowc1rQuadjv-ew541YQLaVmkEcai6leZLwCfCTcsxMX9rt0AmOFg
A JWT token has type MIME type application/jwt, which is plain text. We can pass the token to make a request as in listing 8.6.
http :4000/api/v1/foo Authorization:'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJkZXZpY2VJZCI6ImExYjIiLCJpYXQiOjE1NjUxNjc0NzUsImV4cCI6MTU2NTc3MjI3NSwiaXNzIjoiMTBrLXN0ZXBzLWFwaSIsInN1YiI6ImZvbyJ9.J_tn2BjMNYE6eFSHwSJ9e8DoCEUr_xMSlYAyBSy1-E_pouvDq4lp8QjG51cJoa5Gbrt1bgtDHinJsLncG1RIsGr_cz1rQw8_GlI_-GdhqFBw8dVjlsgykSf5tfaiiRwORmz7VH_AAk-935aVlxMg4mxkbOvN4YDxRLhLb4Y78TA47F__ivNsM4gLD8CHzOUmTEta_pjpZGzsErmYvzDOV6F7rOZcRhZThJxLvR3zskrtx83iaNHTwph53bkHNOQzC66wxNMar_T4HMRWzqnrr-sFIcOwLFsWJKowc1rQuadjv-ew541YQLaVmkEcai6leZLwCfCTcsxMX9rt0AmOFg' HTTP/1.1 200 OK #1 Content-Type: application/json content-length: 90 { "city": "Lyon", "deviceId": "a1b2", "email"<EMAIL_ADDRESS>"makePublic": true, "username": "foo" }
The token is passed with the Authorization HTTP header, and the value is prefixed with Bearer. Here the token allows use to access the resource /api/v1/foo since the token was generated for user foo. Now if we try to do the same without a token, or if we try to access the resource of another use as in listing 8.7, then we get denied.
http :4000/api/v1/abc Authorization:'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJkZXZpY2VJZCI6ImExYjIiLCJpYXQiOjE1NjUxNjc0NzUsImV4cCI6MTU2NTc3MjI3NSwiaXNzIjoiMTBrLXN0ZXBzLWFwaSIsInN1YiI6ImZvbyJ9.J_tn2BjMNYE6eFSHwSJ9e8DoCEUr_xMSlYAyBSy1-E_pouvDq4lp8QjG51cJoa5Gbrt1bgtDHinJsLncG1RIsGr_cz1rQw8_GlI_-GdhqFBw8dVjlsgykSf5tfaiiRwORmz7VH_AAk-935aVlxMg4mxkbOvN4YDxRLhLb4Y78TA47F__ivNsM4gLD8CHzOUmTEta_pjpZGzsErmYvzDOV6F7rOZcRhZThJxLvR3zskrtx83iaNHTwph53bkHNOQzC66wxNMar_T4HMRWzqnrr-sFIcOwLFsWJKowc1rQuadjv-ew541YQLaVmkEcai6leZLwCfCTcsxMX9rt0AmOFg' HTTP/1.1 403 Forbidden #1 content-length: 0
So far so good, but what is in the token string?
If you look closely you will see that a JWT token string is a big line with 3 parts separated by a dot. The 3 parts are of the form header.payload.signature where:
header
ja c ISQG detmcnou wpjr bkr rodu lv ktoen psn kgr gstiunare miaorhtlg genbi gagk, zynpayload
cj c ISUO tnudoecm wrdj laimsc, chhwi txc ISUD eernsit wheer emxz txc gztr kl gro pniscteiicfoa, zny xmvz snz kh tlvx-ltxm,signature
jz bor gniusetar lx kdr aerehd nsb lyapado rwuj hreite z hsedra rteecs xt s vitapre vpx, ededipgnn vn zwry ritaglohm qpv hsoec.The header and payload are encoded with the Base64 algorithm. If you decode the JWT token obtained in listing 8.5, then the header contains:
{ "typ": "JWT", "alg": "RS256" }
while the payload contains:
{ "deviceId": "a1b2", "iat":<PHONE_NUMBER>, "exp":<PHONE_NUMBER>, "iss": "10k-steps-api", "sub": "foo" }
where deviceId is user foo device identifier, sub is the subject (user foo), iat is the date when the token was issued, exp is the token expiration date, and iss is the token issuer (our service).
The signature allows to check that the content of both the header and payload have been signed by the issuer and have not been modified, as long as you know the public key. This makes JWT tokens a great option for authorization and access control in APIs, as a token with all needed claims is self-contained and does not involve making checks for each request against an identity management service like a LDAP / OAuth server.
It is important to understand that anyone with a JWT token can decode its content since Base64 is not an encryption algorithm, so you must never put sensible data like passwords in tokens, even if they are transmitted over secure channels like HTTPS. It is also important to set token expiration dates, so that a compromised token cannot be used indefinitely. There are various strategies for dealing with JWT token expiration, like maintaining a list of compromised tokens in the backend, and combining short expiration deadlines with frequent validity extension requests from clients where the issuer re-sends the token, but with an extended exp claim.
The first thing that we need is a pair of public and private RSA keys, so we can sign JWT tokens. You can generate these using the shell script in listing 8.8.
#!/bin/bash openssl genrsa -out private.pem 2048 openssl pkcs8 -topk8 -inform PEM -in private.pem -out private_key.pem -nocrypt openssl rsa -in private.pem -outform PEM -pubout -out public_key.pem
The .pem files have their key content between '-----' lines, and we need to get rid of these lines to use the keys. Listing 8.9 offers a helper class to read the files and strip these lines.
class CryptoHelper { static String publicKey() throws IOException { return read("public_key.pem"); } static String privateKey() throws IOException { return read("private_key.pem"); } private static String read(String file) throws IOException { Path path = Paths.get("public-api", file); if (!path.toFile().exists()) { #1 path = Paths.get("..","public-api", file); } return Files .readAllLines(path, StandardCharsets.UTF_8) .stream() .filter(line -> !line.startsWith("-----")) #2 .reduce(String::concat) #3 .orElse("OUPS"); } }
Note that the code in CryptoHelper uses blocking APIs. Since this code is run once at initialization and PEM files are small, we can afford a possible yet negligible blocking of the event-loop.
We can then create a Vert.x JWT handler as in listing 8.10.
String publicKey = CryptoHelper.publicKey(); String privateKey = CryptoHelper.privateKey(); jwtAuth = JWTAuth.create(vertx, new JWTAuthOptions() #1 .addPubSecKey(new PubSecKeyOptions() .setAlgorithm("RS256") .setPublicKey(publicKey) .setSecretKey(privateKey))); JWTAuthHandler jwtHandler = JWTAuthHandler.create(jwtAuth); #2
The JWT handler can be used for routes that require JWT authentication, as it decodes the Authorization header to extract JWT data. Listing 8.11 recalls a route with the handler in its handlers chain.
router.get(prefix + "/:username/:year/:month") .handler(jwtHandler) #1 .handler(this::checkUser) .handler(this::monthlySteps);
The JWT handler supports the common authentication API from the vertx-auth-common module, which offers a unified view across different types of authentication mechanisms like databases, OAuth or Apache .htdigest files. The handler puts authentication data in the routing context.
Listing 8.12 shows the implementation of method checkUser where we check that the user in the JWT token is the same as the one in the HTTP request path.
private void checkUser(RoutingContext ctx) { String subject = ctx.user().principal().getString("sub"); #1 if (!ctx.pathParam("username").equals(subject)) { #2 sendStatusCode(ctx, 403); } else { ctx.next(); #3 } }
This provides a simple separation of concerns as the checkUser handler focuses on access-control, and delegates to the next handler in the chain by calling next if access shall be granted, or ends the request with a 403 status code if the wrong user is trying to access a resource.
Knowing that access control is correct, the monthlySteps method in listing 8.13 can focus on making the request to the activity service.
private void monthlySteps(RoutingContext ctx) { String deviceId = ctx.user().principal().getString("deviceId"); #1 String year = ctx.pathParam("year"); String month = ctx.pathParam("month"); webClient .get(3001, "localhost", "/" + deviceId + "/" + year + "/" + month) .as(BodyCodec.jsonObject()) .rxSend() .subscribe( resp -> forwardJsonOrStatusCode(ctx, resp), err -> sendBadGateway(ctx, err)); }
The device identifier is extracted from the JWT token data, and passed along to the web client request.
Last but not least, we need to generate JWT tokens. To do that, we need to make 2 requests to the user profile service: first we need to check the credentials, then gather profile data to prepare a token.
Listing 8.14 shows the handler for the /api/v1/token
route.
private void token(RoutingContext ctx) { JsonObject payload = ctx.getBodyAsJson(); #1 String username = payload.getString("username"); webClient .post(3000, "localhost", "/authenticate") #2 .expect(ResponsePredicate.SC_SUCCESS) .rxSendJson(payload) .flatMap(resp -> fetchUserDetails(username)) #3 .map(resp -> resp.body().getString("deviceId")) .map(deviceId -> makeJwtToken(username, deviceId)) #4 .subscribe( token -> sendToken(ctx, token), err -> handleAuthError(ctx, err)); } private void sendToken(RoutingContext ctx, String token) { ctx.response().putHeader("Content-Type", "application/jwt").end(token); } private void handleAuthError(RoutingContext ctx, Throwable err) { logger.error("Authentication error", err); ctx.fail(401); }
This is a typical RxJava composition of asynchronous operations with flatMap to chain requests. We can also see the declarative API of the Vert.x router where we can specify that we expect the first request to be a success. Listing 8.15 shows the implementation of the fetchUserDetails that gets the user profile data after the authentication request has succeeded.
Finally, listing 8.16 shows how to prepare a JWT token.
private String makeJwtToken(String username, String deviceId) { JsonObject claims = new JsonObject() #1 .put("deviceId", deviceId); JWTOptions jwtOptions = new JWTOptions() .setAlgorithm("RS256") .setExpiresInMinutes(10_080) // 7 days .setIssuer("10k-steps-api") #2 .setSubject(username); return jwtAuth.generateToken(claims, jwtOptions); }
The JWTOptions class offers methods for the common claims from the JWT RFC [JWT] such as the issuer, expiration date and subject. We can see that we did not specify when the token was issued, although there is a method for that in JWTOptions. The jwtAuth object does the right thing here and adds it on our behalf.
So we have a public API that forwards requests to internal services, and this API uses JWT tokens for authentication and access control. We also demonstrated on the command-line that we can interact with the API. In fact any third-party application can talk to our API over HTTP: a mobile phone application, another service, a desktop application, etc. You could think that web applications can also talk to the API from JavaScript code running in web browsers, but it is (fortunately!) not that simple.
Web browsers enforce security policies, among them is the "same-origin policy". Suppose that we load app.js from my.tld:4000/js/app.js, then:
app.js
aj aedwllo rk xsmk qrtsseue rk my.tld:4000/api/foo/bar
,app.js
jc nkr olldeaw vr omxc sqtrseue vr my.tld:4001/a/b/c
cc z efftndeir vgrt jz rkn oyr kzms gnrioi,app.js
zj knr aolewdl rx mosx squtesre kr other.tld/123
sc s riteeffnd zeqr jz rxn bro smax ngiiro.Cross-origin resource sharing is a mechanism for a service to allow incoming requests from other origins [CORS]. For instance the service exposing other.tld/123 can specify that cross-origin requests are allowed from code served from my.tld:4000, or even from any origin. This allows web browsers to proceed with a cross-origin request when the request origin allows it, else deny it, which is the default behavior.
When a cross-origin request is triggered, for instance to load some JSON data, an image or a web font, then a web browser sends a request to the server with the requested resource, and passes a Origin HTTP header. The server then responds with a HTTP header Access-Control-Allow-Origin with the allowed origin, as illustrated in figure 8.4.
A value "*" means that any origin can access the resource, while a value like my.tld means that only cross-origin requests from my.tld are being allowed. In figure 8.4 the request succeeds with the JSON payload, but if the CORS policy forbids the call then the app.js code gets an error while attempting to do a cross-origin request.
Depending on the type of cross-origin HTTP request there are simple and pre-flighted requests that web browsers do. The request in figure 8.4 is a simple one. By contrast a PUT request would need a pre-flighted request as it can potentially have side effects (PUT implies modifying a resource), so a pre-flight OPTIONS HTTP request to the resource is made to check what the CORS policy is, then followed by the actual PUT request when allowed. Pre-flighted requests provide more details such as the allowed HTTP headers and methods, as a server can for example have a CORS policy of forbidding doing DELETE requests or having a ABC header in the HTTP request. I recommend reading [MozillaCORS] as it provides a detailed and approachable explanation on the interactions between browsers and servers with CORS.
Vert.x comes with a ready-to-use CORS handler with the CorsHandler class. Creating a CorsHandler instance requires 3 settings:
Listing 8.17 shows how to install CORS support in a Vert.x router.
Set<String> allowedHeaders = new HashSet<>(); #1 allowedHeaders.add("x-requested-with"); allowedHeaders.add("Access-Control-Allow-Origin"); allowedHeaders.add("origin"); allowedHeaders.add("Content-Type"); allowedHeaders.add("accept"); allowedHeaders.add("Authorization"); Set<HttpMethod> allowedMethods = new HashSet<>(); #2 allowedMethods.add(HttpMethod.GET); allowedMethods.add(HttpMethod.POST); allowedMethods.add(HttpMethod.OPTIONS); allowedMethods.add(HttpMethod.PUT); router.route().handler(CorsHandler #3 .create("*") .allowedHeaders(allowedHeaders) .allowedMethods(allowedMethods));
The HTTP methods are those supported in our API. You can see that we don’t support DELETE for instance. The CORS handler has been installed for all routes, since they are all part of the API and should be accessible from any kind of application, including web browsers. The allowed headers should match what your API needs, and also what clients may pass like specifying a content type, or headers that could be injected by proxies and for distributed tracing purposes.
We can check that CORS is properly supported by doing a HTTP OPTIONS pre-flight request to one of the route supported by the API as in listing 8.18.
$ http OPTIONS :4000/api/v1/token Origin:'http://foo.tld' HTTP/1.1 405 Method Not Allowed access-control-allow-origin: * content-length: 0
By specifying a origin HTTP header, the CORS handler inserts a access-control-allow-origin HTTP header in the response. The HTTP status code is 405 since the OPTION HTTP method is not supported by the specific route, but this is not an issue as web browsers are only interested in the CORS-related headers when they do a pre-flight request.
We have discussed the interesting points in the public API: how to make HTTP requests with the Vert.x web client, how to use JWT tokens, and how to enable CORS support. It is now time to see how we can expose the user web application, and how that application can connect to the public API.
The application is written with the Vue.js JavaScript framework. Vert.x is used to serve the application compiled assets: HTML, CSS and JavaScript.
The corresponding source code is located in the part2-steps-challenge/user-webapp folder of the book source code repository.
Vue.js is worth a book by itself, and we recommend that you read [VuejsInAction] if you are interested in learning this framework. We give a quick overview here since Vue.js is being used as the JavaScript framework for the 2 web applications developed as part of the larger 10k steps application.
Vue.js is a modern JavaScript frontend framework like React or Angular for building modern web applications, including single-page applications. It is reactive as changes in a component model trigger changes in the user interface. Suppose that we display a temperature in a web page, when the corresponding data changes, then the temperature is updated, and Vue.js takes care of (most) of the plumbing for doing that.
Vue.js supports components, where a HTML template, CSS styling and JavaScript code can be grouped together as in listing 8.19.
A Vue.js project can be created using the Vue.js command-line interface [VueCli]:
$ vue create user-webapp
The yarn build tool can then be used to install dependencies (yarn install), serve the project for development with automatic live-reload (yarn run serve), and build a production version of the project HTML, CSS and JavaScript assets (yarn run build).
The user web application is a single-page application with 3 different screens: a login form, a page with user details, and a registration form.
The key Vue.js files are the following:
src/main.js
: ryk etnyr pointsrc/router.js
: rgk Edk.ic uetror drrz atsciedpsh kr xpr notmpnosce vl qor 3 fierndfet nscsreesrc/DataStore.js
: sn tocjeb rx xpfu rkq itipncalopa sreot nisgu vgr odw rwesrob callo otegsar BVJ, dahres ognam fsf nceserssrc/App.vue
: rxp nzjm nmpnetooc qrrz snmotu odr Zxq.ia etorursrc/views
sinaoctn rqx 3 ecrnse nncemstoop: Home.vue
, Login.vue
nzh Register.vue
.The Vue.js router configuration is given in listing 8.20.
import Vue from 'vue' import Router from 'vue-router' import Home from './views/Home.vue' import Login from './views/Login.vue' import Register from './views/Register.vue' Vue.use(Router) export default new Router({ routes: [ { path: '/', #1 name: 'home', #2 component: Home #3 }, { path: '/login', name: 'login', component: Login }, { path: '/register', name: 'register', component: Register }, ] })
The application code is co-located in the same module as the Vert.x application that serves the user web application, so you will find the usual Java source files under src/main/java and a Gradle build.gradle.kts file. The Vue.js compiled assets (yarn build) must be copied to src/main/resources/webroot/assets for the Vert.x-based service to serve them.
This makes for 2 build tools in a single project, and fortunately they can co-exist peacefully. In fact, it is very easy to call yarn from Gradle as the com.moowork.node Gradle plugin provides a self-contained Node environment. Listing 8.21 shows the Node-related configuration of the user web application Gradle build file.
com.moowork.node
Gradle pluginimport com.moowork.gradle.node.yarn.YarnTask plugins { id("com.moowork.node") version "1.3.1" #1 } tasks.register<YarnTask>("buildVueApp") { #2 dependsOn("yarn_install") #3 // (...) #4 args = listOf("build") #5 } tasks.register<Copy>("copyVueDist") { #6 dependsOn("buildVueApp") from("$projectDir/dist") into("$projectDir/src/main/resources/webroot/assets") } val processResources by tasks.named("processResources") { #7 dependsOn("copyVueDist") } val clean by tasks.named<Delete>("clean") { #8 delete("$projectDir/dist") delete("$projectDir/src/main/resources/webroot/assets") } // (...)
The buildVueApp and copyVueDist tasks are inserted as part of the regular project build tasks, so the project builds both the Java Vert.x code and the Vue.js code. We also customize the clean task to remove the generated assets.
Let us look at one of the Vue.js components: the login screen as found in figure 8.5.
The file for this component is src/views/Login.vue. The component shows the login form, and when submitted must call the public API to get a JWT token. On success, it must store the JWT token locally, then switch the view to the home component. On error, it must stay on the login form and display an error message.
The HTML template part of the component is given in listing 8.22.
<template> <div> <div class="alert alert-danger" role="alert" v-if="alertMessage.length > 0"> #1 {{ alertMessage }} #2 </div> <form v-on:submit="login"> #3 <div class="form-group"> <label for="username">User name</label> <input type="username" class="form-control" id="username" placeholder="somebody123" v-model="username"> #4 </div> <div class="form-group"> <label for="password">Password</label> <input type="password" class="form-control" id="password" placeholder="abc123" v-model="password"> </div> <button type="submit" class="btn btn-primary">Submit</button> </form> <div> <p>...or <router-link to="/register">register</router-link></p> #5 </div> </div> </template>
The JavaScript part of the component provides the component data declaration as well as the login method implementation. We use the Axios JavaScript library to make HTTP client calls to the public API. Listing 8.23 provides the component JavaScript code.
import DataStore from '../DataStore' import axios from 'axios' export default { data() { #1 return { username: '', password: '', alertMessage: '' } }, methods: { #2 login: function () { if (this.username.length === 0 || this.password.length === 0) { #3 return } axios .post("http://localhost:4000/api/v1/token", { #4 username: this.username, password: this.password }) .then(response => { DataStore.setToken(response.data) #5 DataStore.setUsername(this.username) this.$router.push({name: 'home'}) #6 }) .catch(err => this.alertMessage = err.message) #7 } } }
The component data properties are updated as the user types text in the username and password fields, and the login method is called on form submit. If the call succeeds, then the application moves to the home component.
Listing 8.24 is extracted from the code of the Home.vue component, and shows how to use the JWT token to fetch the user total number of steps.
axios .get(`http://localhost:4000/api/v1/${DataStore.username()}/total`, { headers: { 'Authorization': `Bearer ${DataStore.token()}` #1 } }) .then(response => this.totalSteps = response.data.count) #2 .catch(err => { if (err.response.status === 404) { this.totalSteps = 0 } else { this.alertMessage = err.message } })
Let us now see how to serve the web application assets with Vert.x
The Vert.x code does not have much to do beyond starting a HTTP server and serving static content. Listing 8.25 gives the content of the rxStart method of the UserWebAppVerticle class.
@Override public Completable rxStart() { Router router = Router.router(vertx); router.get("/").handler(ctx -> ctx.reroute("/index.html")); #1 router.route().handler(StaticHandler.create("webroot/assets")); #2 return vertx.createHttpServer() .requestHandler(router) .rxListen(HTTP_PORT) .ignoreElement(); }
The StaticHandler caches files in memory, unless configured otherwise in the call to the create method. Disabling caching is useful while in development mode, because you can modify static assets content and see changes by reloading in a web browser without having to restart the Vert.x server. By default static files are resolved from the webroot folder in the classpath, but you can override it as we did by specifying webroot/assets.
Now that we discussed how to use the Vert.x web stack it is time to focus on testing the services that compose the reactive application.
Testing is a very important concern, especially as there are multiple services involved in the making of the 10k steps challenge reactive application. There is no point in testing that the user web application service does deliver static content properly, while it is crucial to have tests covering interactions with the public API service. Let us discuss how to write integration tests for this service.
The public API source code reveals an IntegrationTest class. It contains several ordered test methods that check the API behavior:
Since the public API service depends on the activity and user profile services, we either need to mock them with fake services that we run during the tests execution, or deploy them along with all their dependencies like databases. Either approach is fine, and in the next chapters we will sometimes create a fake service for running our integration tests, and sometimes we will just deploy the real services.
In this case we are going to deploy the real services, and we need to make this from JUnit 5 in a self-contained and reproducible manner. We first need to add the project dependencies as in listing 8.26.
testImplementation(project(":user-profile-service")) #1 testImplementation(project(":activity-service")) testImplementation("io.vertx:vertx-pg-client:$vertxVersion") #2 testImplementation("org.testcontainers:junit-jupiter:$testContainersVersion") #3 testImplementation("org.junit.jupiter:junit-jupiter-api:$junit5Version") testImplementation("io.vertx:vertx-junit5:$vertxVersion") testImplementation("io.rest-assured:rest-assured:$restAssuredVersion") #4 testImplementation("org.assertj:assertj-core:$assertjVersion")
These dependencies bring us 2 useful tools for writing tests:
The preamble of the test class is in listing 8.27.
@ExtendWith(VertxExtension.class) #1 @TestMethodOrder(OrderAnnotation.class) #2 @TestInstance(TestInstance.Lifecycle.PER_CLASS) @DisplayName("Integration tests for the public API") @Testcontainers #3 class IntegrationTest { @Container private static final DockerComposeContainer CONTAINERS = new DockerComposeContainer(new File("../docker-compose.yml")); #4 // (...) }
Test Containers gives lots of choices for starting one or many containers. It supports generic Docker images, specialized classes for common infrastructure (e.g., PostgreSQL, Apache Kafka, etc) and Docker Compose. Here we re-use the Docker Compose descriptor for running the whole application (docker-compose.yml), and the containers described in the file are started before the first test is run. The containers are destroyed when all tests have executed. This is very interesting as we get to write integration tests against the real infrastructure services that would be used in production.
The prepareSpec method is annotated with @BeforeAll, and is used to prepare the tests. It inserts some data in the PosgreSQL database for the activity service and then deploys the user profile and activity verticles. It also prepares a RequestSpecification object from REST Assured, as show in listing 8.28.
requestSpecification = new RequestSpecBuilder() .addFilters(asList(new ResponseLoggingFilter(), new RequestLoggingFilter())) #1 .setBaseUri("http://localhost:4000/") .setBasePath("/api/v1") #2 .build();
This object is shared among all tests methods, as they all have to make requests to the API. We enable logging of all requests and responses for easier debugging, and also set /api/v1 as the base path for all requests.
The test class maintains a hash map of users to register and later use in calls, as well as a hash map of JWT tokens, as in listing 8.29.
private final HashMap<String, JsonObject> registrations = new HashMap<String, JsonObject>() { #1 { put("Foo", new JsonObject() .put("username", "Foo") .put("password", "foo-123") .put("email"<EMAIL_ADDRESS>.put("city", "Lyon") .put("deviceId", "a1b2c3") .put("makePublic", true)); // (...) }; private final HashMap<String, String> tokens = new HashMap<>(); #2
Listing 8.30 is the first test where the users from the registrations hash map are being registered.
@Test @Order(1) @DisplayName("Register some users") void registerUsers() { registrations.forEach((key, registration) -> { given(requestSpecification) .contentType(ContentType.JSON) .body(registration.encode()) #1 .post("/register") #2 .then() .assertThat() .statusCode(200); #3 }); }
The REST Assured fluent API allows us to express our request, and then do an assertion on the response. It is possible to extract a response a text or JSON to perform further assertions, as in listing 8.31 which is extracted from the test method that retrieves JWT tokens.
JsonObject login = new JsonObject() .put("username", key) .put("password", registration.getString("password")); String token = given(requestSpecification) .contentType(ContentType.JSON) .body(login.encode()) .post("/token") .then() .assertThat() .statusCode(200) .contentType("application/jwt") #1 .extract() #2 .asString(); assertThat(token) #3 .isNotNull() .isNotBlank(); tokens.put(key, token);
The test fetches a token, then assets that the token is neither a null value or an blank string (empty or with spaces). Extracting JSON data is similar, as shown in listing 8.32.
JsonPath jsonPath = given(requestSpecification) .headers("Authorization", "Bearer " + tokens.get("Foo")) #1 .get("/Foo/total") .then() .assertThat() .statusCode(200) .contentType(ContentType.JSON) .extract() .jsonPath(); assertThat(jsonPath.getInt("count")).isNotNull().isEqualTo(6255); #2
The test fetches the total number of steps for user Foo, extracts the JSON reponse, then checks that the steps count (the count key in the JSON response) is equal to 6255.
The integration test can be run with Gradle (./gradlew :public-api:test) or from a development environment, as show in figure 8.6.
You now have a good understanding of using the Vert.x web stack both for exposing endpoints and consuming other services. The next chapter focuses on the messaging and event streaming stack of Vert.x.
[JWT] Internet Engineering Task Force (IETF). May 2015. RFC 7519 - JSON Web Token (JWT). tools.ietf.org/html/rfc7519
[CORS] WhatWG. Fetch (living standard). fetch.spec.whatwg.org/
[MozillaCORS] Mozilla Developer Network. Retrieved August 2019. Cross-Origin Resource Sharing. developer.mozilla.org/en-US/docs/Web/HTTP/CORS
[VueCli] Vue.js project. Retrieved August 2019. Vue CLI. cli.vuejs.org/


Add an introductory paragraph with more information about yourself, including what things you're passionate about, programming languages you enjoy writing in, etc.
Need a paragraph here.
I enjoy writing front-end code with these technologies.
Need a paragraph here.
Welcome to the HTML Portfolio Project


Cyberpunk FPS ‘Ghostrunner’ to be Produced by 3D Realms
by Mike WilsonThe house that Duke Nukem built, aka 3D Realms, have announced that they will be producing and distributing One More Level’s cyberpunk action game Ghostrunner, which was last shown off at this year’s Gamescom. All in! Games will still be publishing the game, which is slated for a 2020 release.
Look for Ghostrunner on PC, PlayStation 4 and Xbox One.


{% extends "base/base.html"%} {% load static %} {% block title %}Login{% endblock %} {% block content %}
Don't have an account? Sign up now


HELLO GUYS.
Welcome to my page!!!
Here are the detailed discription for you to navigate through my page.
Contents of my page.
- The first/current page is the home page.
- The second page is the discription page where you can find more about me.
- The third page contains my Online resume.
- The fourth page contains the top 21 photography of Nepal by Nepal's top 21.
- The feedback page is for user feedback. You can post your feedback on give feedback and see the given feedbacks from see given feedbacks.
Are you interested in doing projects with me?
If you like my projects and want to explore them in great details, please feel free to contact me by clicking at this botton. Also please feel free to leave a comment/feedback on what you feel about my page. You can do that by clicking on this botton. Your feedbacks are greatly appriciated. Thank you !!!
University of Louisiana at Monroe !!!
By the bayou’s tranquil water,
Where friendships thrive and grow,
proudly stands our alma mater
ever home for us to go.
Here cypress stand in splendor
and gracefully they touch the breeze.
Though friends may leave and lives may change
faithful we shall always be.
Shining bright the bayou’s gem ever
loyal to ULM.


I stand at the window in our suite’s living room and stare blankly at the city landscape, pondering the confrontation at our gun deal in Boston. Taking those pistols was a risk.
Cars crawl along the distant highways on this foggy morning, and it seems like I might have to swallow my pride and keep a long distance between our boss and us after our mistake. The deal in five hours might be the end of my life.
I sip my water and things slow down. My mind compresses as my possibly impending death intensifies my concentration. I stare out the window and assess why this is my current environment. I have five hours to live. For a twenty two year old man taking on the entire world, I threw down as much as anyone else could have. The water sinks down my esophagus and the chill from the window glass makes it to my cheeks.
With my given opportunities, I influenced the confining society that marginalized me without letting it influence me. Running guns is a risky business. I made a decision. Having only five more hours to live will not dictate my behavior.
Spy thriller a la 'James Bond' meets 'The Social Network'; the entrepreneuring milieu of Millennials is brought to foreign cultures with the college-aged Preston going big in international start-ups each time around in this book series, with a powerful spy watching his back in a second narrative in each installment. '2' completed, '2.1' begun.
Kayla, a pretty, spunky India-American adopted college girl struggling with societal concerns and social isolation finds a handwritten book belonging to a historical group of wizards and witches that gives her life new meaning.
Seeking a writing group to Work For Hire with Mr. Payne on a concept of a successful professional who gets his cash stolen from his "secure" bank account and has to hire secretive "lobbyists" to track down the thieves, which turns into a fight to the death. The young up-and-coming, assault rifle toting, thoughtful professional "lobbyist" will be played by Mr. Payne and there will be several human condition elements in the writing that are remaining under an NDA for hard-hitting statements rather than an escapism action flick.
An application for writers to sell their books to other writers which is premiering the patent-pending service of giving books maturity ratings automatically. The link for development hosting is provided below for all that are curious. If you upload a pdf up to about three pages long you will receive your maturity rating. The rest is in development and on approximately a 2018-2019 minimum viable product timeline (Open to help or backing, too. Say Hi!): Book App


Pwn tools allows for easy connecting to remote hosts/ports. A typical template is like:
HOST, PORT = "<RHOST>","<RPORT>
r = remote(HOST, PORT)
r.recvuntil("Enter username") #whatever the server says
r.sendline("My data") #whatever you need to say
r.recvuntil("Enter password") #whatever the server continues to say
r.sendline(payload) #send the payload
r.interactive() #drop to interactive shell
Pwn tools also allows for easy definition of target for formatting
context(os="linux", arch="i386")
Pwn tools allows for easy writing of memory addresses in exploits. No need for little endian, just copy and paste when using p32()
ret2libc = p32(0xf7e4c060) # System()


|
| Recommends |
|
|
|
|
| DVD New Releases |
|
|
|
|
Cold Mountain
DVD
15
RRP £22.99
£16.99
At the dawn of the Civil War, the men of Cold Mountain, North Carolina, rush to join the Confederate .. more
|
|
|
|
| |
|
Torque
DVD
15 |
RRP £15.99 | £11.99 |
|
| |
|
| |
|
| |
|
| |
|
| |
|
|
|
|
| DVD Pre Orders |
|
|
|
|
| Out on Jul 19, 2004 |
|
|
|
| Out on Jul 26, 2004 |
|
|
|
| Out on Aug 2, 2004 |
|
|
|
| Coming Soon |
|
|
|
|
DVD Features |
|
|
|
|
| DVD chart |
|
1 |
|
2 |
|
3 |
Torque
DVD
15 |
| RRP £15.99 |
| £11.99 |
|
|
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
|
|


DesnoGuns Mod r025
- NEW: full support for Minecraft PE 1.2 beta (make sure to use latest BlockLauncher beta)
- UPDATE: changed IDs of some guns to avoid conflicts with Jukebox Discs
- FIX: fixed crash with Crossbow Explosive
DesnoGuns Mod r024
- NEW: the Exoskeleton armor!
- NEW: separated tabs for guns using InventoryPlus
DesnoGuns Mod r023
- FIX: fixed not working recoil
- FIX: fixed UI not hidden when opening the inventory or the pause menu
- FIX: fixed chainsaw and machete ability to cut wood and grass
DesnoGuns Mod r022
- NEW: experimental support for Minecraft PE 1.1.0
- NEW: THE MELEE WEAPONS UPDATE!
- NEW: 7 new melee weapons have been added to the mod so you can now smash zombies and hostile mobs!
DesnoGuns Mod r021
- FIX: volume option not applied to miniguns
- FIX: explosion too powerful due to changes in the latest versions of MCPE
- UPDATE: smoother aiming animation
DesnoGuns Mod r020
- UPDATE: full support for 1.0.0 (use the latest version of BlockLauncher)
- FIX: huge lags when shooting explosive arrows in the air
- FIX: lags caused by arrows on the ground
- FIX: wrong health damage when hitting the mob multiple times
- FIX: bouncing back arrows workaround not working
DesnoGuns Mod r019
- NEW: support 0.16.x (check on the Play Store if you're using the latest version of BlockLauncher!)
- NEW: the Iron Sights update!
- NEW: some guns will show their iron sight when aiming (currently available for AK47, AUG, Desert Eagle, FNSCAR, Mini-Uzi, MP5, P90, Skorpion)
- NEW: option for disabling iron sight if you don't like them
- FIX: explosions not destroying blocks
- ADDONS: fix custom guns with buttonType "on_touch_with_wait" not shooting when using an aim image
- ADDONS: add isIronSight property that must be set to true when using an iron sight and not a full-screen scope for the gun (see Example Addon)
DesnoGuns Mod r018
- NEW: a new Sniper Rifle, the M40A3 Night Vision
- NEW: Night Binoculars
- NEW: Jungle Camo Armor
- UPDATE: the Juggernaut is now stronger than the Diamond Armor but it also adds a slowness effect
- UPDATE: more realistic binoculars images
- FIX: the UI of the mod and of the guns now is closed when opening the inventory or the chat menu
- FIX: fixed Sniper Ammo item not added in the creative inventory
- ADDONS: new APIs for Addons Developers! Support for a custom image when aiming (customAimImageLayerPath String), night vision effect when aiming (hasNightVision boolean), custom sound of the countdown when using bullet type "normal_explosive_on_time" (countdownSoundExplosiveOnTime String)
DesnoGuns Mod r017
- FIX: workaround fix for crash at startup caused by a bug of BlockLauncher with armors. I had to remove the Juggernaut (temporarily) to fix the problem
DesnoGuns Mod r016
- FIX: fixed lags when shooting and improved performance
- FIX: other bug fixes
DesnoGuns Mod r015
- UPDATE: added ammunition items and the medical kit in the food and potions tab in the creative inventory
- FIX: fixed sounds interruptions
- FIX: fixed crash when clicking the reload text while shooting
DesnoGuns Mod r014
- FIX: finally fixed the arrows bouncing back bug! (only with BlockLauncher 1.12.3 or up)
- FIX: fixed a critical bug when creating addons
- UPDATE: reload in creative now is enabled by default (can be disabled in Settings)
- UPDATE: some sounds improvements and changes
DesnoGuns Mod r013
- NEW: easier installation, with just one .modpkg file that can be imported in BlockLauncher in the ModPE section
- UPDATE: offline sounds installation
- UPDATE: better information UI for guns specifications when using addons
- FIX: binoculars not craftable
- FIX: fixed a bug that showed the user a non-existent error with addons
DesnoGuns Mod r012
- NEW: support for Minecraft PE 0.14.0
- NEW: support for DesnoGuns addons, a new way to add new guns in the game for everyone!
- NEW: Ray Gun
- NEW: Binoculars
- NEW: Zoom Binoculars (Pro item)
- UPDATE: added the Juggernaut armor to the creative inventory
- FIX: many bugs fixed
DesnoGuns Mod r011
- NEW: support for Minecraft PE 0.13.1
- WARNING: since BlockLauncher is not yet updated for 0.13.1 grenades are buggy
DesnoGuns Mod r010
- NEW: added the Multiple Rocket Launcher
- UPDATE: added a smoke trail behind bullets of rocket launchers
- FIX: fixed explosive bullets sometimes exploding in air
- FIX: enchanted golden apple and other items were recognized as guns
- FIX: fixed the crash with the Minecraft style buttons
DesnoGuns Mod r009
- NEW: support for Minecraft PE 0.13.x
- UPDATE: add blindness effect for the smoke grenade
- UPDATE: add immersive mode support
- FIX: some IDs have been changed to fix a bug of the Creative inventory, IDs changed: AK47, AK74, AT4, AUG, Bizon
DesnoGuns Mod r008
- NEW: support for Minecraft PE 0.12.x
DesnoGuns Mod r007
- NEW: Crossbow
- NEW: Crossbow Explosive
- NEW: Smoke Grenade
- NEW: Riot Shield
- NEW: MSR (pro item)
- UPDATE: many IDs changed! (IDs changed: all the ammunitions and these items: Molotov, Fragment Grenade, Grenade, Medical Kit, Parachute, Knife, DesnoGuns Info, .44Magnum)
- FIX: fixed Settings section not working on Android 4.0
- FIX: fixed a crash with grenades when leaving the game
- FIX: fixed volume options not applied to reload sounds and miniguns
DesnoGuns Mod r006
- NEW: Minecraft style for UIs
- NEW: new option in Settings to enable Minecraft style for the "fire" and "aim" buttons
- NEW: volume option in Settings
- NEW: slightly better animation when aiming with a Sniper Rifle
- NEW: volume of sound based on the distance from the source (for Molotov and Incendiary Grenade Launcher)
- UPDATE: The Juggernaut armor now doesn't override the Chain armor (IDs changed!)
- UPDATE: code re-written in many parts and improved: this should increase performance when loading the script at startup
- FIX: fixed disappearing items from the creative menu
- FIX: fixed the "double tap fast the aim button" bug that caused glitches with zoom
- FIX: fixed shadows and collision size of grenades
- FIX: fixed a graphical glitch that was happening when using other Texture Packs at the same time
DesnoGuns Mod r005
- NEW: support for Minecraft PE 0.11.x
- NEW: compatibility with Android M
- UPDATE: some IDs have been changed because some of them were overriding beetroot and related items, IDs changed: DesnoGuns Info, .44Magnum, Grenade, Fragment Grenade, Molotov.
- FIX: fix the "resurrector knife" bug
- FIX: fix the "shooting while reload" bug
- FIX: fix the "parachute not working on grass" bug
- FIX: before, on some devices, while aiming with a sniper rifle there was one line of pixels not black. Now it has been fixed
DesnoGuns Mod r004
- UPDATE: items and guns moved in the Tool category in the Creative inventory
- NEW: new weapon: .44 Magnum
- NEW: new armor: Juggernaut
- NEW: option in Settings to switch the position of the "fire" and "aim" buttons
- UPDATE: improvements in the Settings page
- FIX: fix bug of sounds installation when there isn't any Internet connection available
- FIX: guns now render vertically instead of horizontally in the third person view
DesnoGuns Mod r003
- NEW: automatic sounds installation
- NEW: added recoil for all the guns
- NEW: new weapon: Flamethrower
- NEW: new weapon: Minigun Explosive
- NEW: new weapon: Makarov
- NEW: new weapon: AA-12 (pro item)
- NEW: new weapon: Incendiary Grenade Launcher (pro item)
- NEW: added texture pack with bullet texture instead of arrow
- NEW: option in Settings to enable reloading for guns also in Creative
- NEW: option in Settings to enable instant reload in Creative (only when reload in Creative is enabled)
- NEW: option to display the gun's name near the ammo text
- NEW: added an Easter Egg :P
- UPDATE: updated the Medical Kit with a new UI
- UPDATE: improved memory management
- UPDATE: improved start-up speed
- UPDATE: added sound when the parachute opens
- UPDATE: added sound when you try to shoot but the ammo is 0
- UPDATE: guns are displayed in alphabetical order in the Creative inventory
- FIX: fix Molotov didn't burn grass
- FIX: fix shadow for buttons in Android Lollipop
DesnoGuns Mod r002
- FIX: gun's sound now won't be displayed in your music player
- FIX: other bug fixes (here more informations https://bitbucket.org/Des...c6a5c9)
DesnoGuns Mod r001
- Initial release


45+ Structured Premium Niche Demos for Every Category.
Lorem ipsum dolor sit amet consectetur adipisicing, elit. Doloremque animi, omnis consequuntur harum atque nostrum! Cupiditate consequatur veritatis culpa commodi corporis.
65+ One-Page Demos for a Quick & Effective Landing Page.
Dramatically synergize pandemic content for open-source niches. Synergistically maximize cooperative e-markets before intermandated networks.


Mysterious Wizard:
I separated her personality into two bodies, and figured the stronger would prey on the weaker. Well, it turned out a little different.
The Lord still controls the forest with magic. At least my friend Loricom still has hope. He brought the Key of Seal from the place where the sun sets.
He has a strange taste for women.
"The place where the sun sets?"


Small Town Elegance
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
READ MOREEditorial June 7, 2018
{% extends "./common/layout.html" %} {% block headscript %} {% endblock %} {% block body %}
Small Town Elegance
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
READ MOREEditorial June 7, 2018


Usage:
hit the start button;
generate some traffic;
hit the stop button to display the resulting graph in a new tab.
Each tab has its own context, parallel recordings are possible.
|


This chart shows the rate of increase or decrease in border patrol apprehensions from month to month for each fiscal year from 2000 to 2013. Each line represents one year of data with the first month used as a benchmark. The bold line is the average of all 13.


---
sort_order: 13
tei_id: rdx_b5h9g.p.idm481120
annotation_count: 0
images:
small-thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchnm/mini-thumbnail/
json: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchnm/info/
full: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchnm/fs/
page: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchnm/single-page/
thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchnm/thumbnail/
title: Page 13
number: 13
---
{% raw %}JACOB BODGES,{% endraw %}
{% raw %}5{% endraw %}
{% raw %}sprightly, insolent and daring, he was,{% endraw %}
{% raw %}alternately, the source of amusement and{% endraw %}
{% raw %}the subject of abuse to the officers and{% endraw %}
{% raw %}crew of the ship; yet it would seem that{% endraw %}
{% raw %}he was capable of rendering himself use¬{% endraw %}
{% raw %}ful even in this humble station.{% endraw %}
{% raw %}In the capacity of waiting and caoin{% endraw %}
{% raw %}boy on board different ships, and after¬{% endraw %}
{% raw %}wards as a common sailor, he continued{% endraw %}
{% raw %}for a great number of years. He visited{% endraw %}
{% raw %}almost every port in Europe, as well as{% endraw %}
{% raw %}other countries, mingling in scenes of de¬{% endraw %}
{% raw %}gradation and vice abroad, till he acquired{% endraw %}
{% raw %}the hardness, enterprise and viciousness{% endraw %}
{% raw %}of the most dissolute seaman. And who{% endraw %}
{% raw %}is more reckless and abandoned than a{% endraw %}
{% raw %}homeless, friendless African sailor! Ad-{% endraw %}
{% raw %}dieted in early life to every species of pro-{% endraw %}
{% raw %}faneness, the sin of intemperance soon{% endraw %}
{% raw %}followed. To use his own language, <he{% endraw %}
{% raw %}was always profane*and always bad.{% endraw %}
{% raw %}After pursuing a sea-faring life till{% endraw %}
{% raw %}-sometime during the last war between{% endraw %}
{% raw %}this country and England, the vessel in{% endraw %}
{% raw %}which he served was driven into New{% endraw %}
{% raw %}1*{% endraw %}


| {{qmsEntryInspection.id}} |
{{qmsEntryInspection.materielId}} |
{{qmsEntryInspection.supplierId}} |
{{qmsEntryInspection.okNumber}} |
{{qmsEntryInspection.ngNumber}} |
{{qmsEntryInspection.serialNumber}} |
{{qmsEntryInspection.productionCd}} |
{{qmsEntryInspection.checkDate | date:'medium'}} |
{{qmsEntryInspection.fileNumber}} |
{{qmsEntryInspection.flagStatus}} |
{{qmsEntryInspection.compPkid}} |
{{qmsEntryInspection.entryId}} |
{{qmsEntryInspection.remark}} |
{{qmsEntryInspection.groupCd}} |
{{qmsEntryInspection.reserveFirst}} |
{{qmsEntryInspection.reserveSecond}} |
{{qmsEntryInspection.reserveThird}} |
{{qmsEntryInspection.makeUser}} |
{{qmsEntryInspection.makeTime | date:'medium'}} |
{{qmsEntryInspection.modifyUser}} |
{{qmsEntryInspection.modifyTime | date:'medium'}} |
|


#634 ex_r
examiner
excavator
excelsior
exchequer
exciter
executioner
executor
exhibitor
extensor
exterior
exterminator
extinguisher
extractor
extracurricular
extrasolar
extruder


Consumer Guide to Home Energy
Savings
Home
Energy Checklist for Action
Home energy checklist
for action
Here's a simple checklist
to give you an idea of the things you can learn about in the Consumer
Guide to Home Energy Savings.
To Do Today
Turn
down the temperature of your water heater to the warm setting (120°F).
You'll not only save energy, you'll avoid scalding your hands.
Check
if your water heater has an insulating blanket. An insulating blanket will pay
for itself in one year or less!
If
you have one of those silent guzzlers, a waterbed, make your bed today. The
covers will insulate it, and save up to one-third of the energy it uses.
Start
using energy-saving settings on refrigerators, dishwashers, washing machines,
and clothes dryers.
Survey
your incandescent lights for opportunities to replace them with compact fluorescents.
These new lamps can save three-quarters of the electricity used by incandescents.
The best targets are 60-100W bulbs used several hours a day. Measure the clearance
in the fixtures to make sure they will accommodate compact fluorescents, which
are slightly bigger than incandescents.
Check
the age and condition of your major appliances, especially the refrigerator.
You may want to replace it with a more energy-efficient model before it dies.
Clean
or replace furnace, air-conditioner, and heat-pump filters.
This Week
Visit
the hardware store. Buy a water-heater blanket, low-flow showerheads, faucet
aerators, and compact fluorescents, as needed. If you can't find compact fluorescents
locally, check out ENERGYguide or Energy
Federation Incorporated.
Rope
caulk very leaky windows.
Assess
your heating and cooling systems. Determine if replacements are justified, or
whether you should retrofit them to make them work more efficiently to provide
the same comfort (or better) for less energy.
This Month
Collect
your utility bills. Separate electricity and fuel bills. Target the biggest
bill for energy conservation remedies.
Crawl
into your attic or crawlspace and inspect for insulation. Is there any? How
much?
Insulate
hot water pipes and ducts wherever they run through unheated areas.
Seal
up the largest air leaks in your housethe ones that whistle
on windy days, or feel drafty. The worst culprits are usually not
windows and doors, but utility cut-throughs for pipes ("plumbing
penetrations"), gaps around chimneys and recessed lights in insulated
ceilings, and unfinished spaces behind cupboards and closets. Better
yet, hire an energy auditor with a blower door to point out where
the worst cracks are. All the little, invisible cracks and holes
may add up to as much as an open window or door, without you ever
knowing it!
Install
a clock thermostat to set your thermostat back automatically at night.
Schedule
an energy audit (ask your utility company or state energy office) for more expert
advice on your home as a whole.
This Year
Insulate.
If your walls aren't insulated have an insulation contractor blow cellulose
into the walls. Bring your attic insulation level up to snuff.
Replace
aging, inefficient appliances. Even if the appliance has a few useful years
left, replacing it with a top-efficiency model is generally a good investment.
Upgrade
leaky windows. It may be time to replace them with energy-efficient models or
to boost their efficiency with weatherstripping and storm windows.
Reduce
your air conditioning costs by planting shade trees and shrubs around your houseespecially
on the west side.
Know
that you are making a difference!


SamplingFrequency
public enum SamplingFrequency : UInt8
Undocumented
-
Undocumented
Declaration
Swift
case hz96000 = 0
-
Undocumented
Declaration
Swift
case hz88200 = 1
-
Undocumented
Declaration
Swift
case hz64000 = 2
-
Undocumented
Declaration
Swift
case hz48000 = 3
-
Undocumented
Declaration
Swift
case hz44100 = 4
-
Undocumented
Declaration
Swift
case hz32000 = 5
-
Undocumented
Declaration
Swift
case hz24000 = 6
-
Undocumented
Declaration
Swift
case hz22050 = 7
-
Undocumented
Declaration
Swift
case hz16000 = 8
-
Undocumented
Declaration
Swift
case hz12000 = 9
-
Undocumented
Declaration
Swift
case hz11025 = 10
-
Undocumented
Declaration
Swift
case hz8000 = 11
-
Undocumented
Declaration
Swift
case hz7350 = 12
-
Undocumented
Declaration
Swift
public var sampleRate: Float64 { get }
-
Undocumented
Declaration
Swift
public init(sampleRate: Float64)


Are you a user: A Survey
Have you ever used...
- knowledge factor
- possession factor
- inherent factor
- single factor
- two factor
- three factor
Types of Factors - Knowledge
"Something You Know"
shared secrets
- password
- PIN
- secret questions
- difficult life knowledge
Types of Factors - Possession
"Something You Have"
keys and locks
- atm card
- an actual key
- disconnected tokens (SecurID thumb stick)
- connected tokens (usb drive, Square)
- OTP = One Time Password (text message)
- TOTP = Time-Based One Time Password (Google Authenticator)
- Utilizes otpauth:// protocol
Types of Factors - Inherent
"Something You Are"
biometrics
- retina scanner
- fingerprint scanner
- voice recognition
- ear imprint (Ant-Man?)
Some servers that use TOTP
- Salesforce
- Microsoft
- Facebook
- Google
- AWS
Some clients that implement TOTP
- 1Password
- Authy
- Google Authenticator
Resources
see: biometrics.mainguet.org
Light
...ng Talk?
About the Proof of Concept
- Time box: 3hrs
- Node.js v4.2.2
- Sails.js
- JWT - jwt.io
- Passport
- Google Authenticator
- MySQL
- jQuery
Why Passport
- Strategy pattern usage
- Simplified interface
- Independently tested
Why JWT
- Provides simplified user packet handling
- Stateless
- Still OAuth compatible
- Less "chatty"


carpel thaliana NAM/miR expression gynoecium module fusion truncatula Figure CUC margins Plant ovule development Arabidopsis MtNAM role {border-style fused monocarpous Medicago px;} #ffffff;} aux- closure angiosperm NAM flower flowers mutants carpels showing developmental early single wild-type cal present Nikovics conserved produced stages COTYLEDON Carpel Figures common gynoecia model orthologs primordia species transformation using Aida Table Thus, abaxial angiosperms gene genes genetic observed plants syncarpous thaliana, CUP-SHAPED Cell Stage angiosperms, control development, development. form involved margins. meristem miR organ px; situ studies syncarpy unfused {font-family CUCg-m Development Fusion Galbiati Ishida MRCA MtNAMg-m MtNAMg-wt Number Sci. Vialette-Guiraud data evolution expressed floral font-size leaf living miR-resistant petals similar thaliana. transformed Role Smyth Tasaka analysis ancestor angiosperms. congenitally containing double; eurosid formation mechanism transcription truncatula, truncatula. (including APICAL Accordingly, Blein Bot. Fabales MERISTEM Module Recherche Sieber adaxial auxin balance base border-color border-width breakdown bud buds earliest events hybridization later mechanisms performed phylogeny plant regulation respectively. revealed seed solid; suggests wall {font-style {font-weight ./dev. ANR--BSV- Arabidopsis. Armbruster Bars Benlloch Bennett Bremer CUCg-wt Expression FIGURE Morin National Science Syncarpy background bold causes character closed construct courier; described detected differences different disruption diverging em; emerge eurosids eurosids. expanding factors flower, following function fusion. genes. gynoecia, gynoecial gynoecium, including indicates microscope molecular monocarpy mutant open origin ovary patterns petal plants. post-transcriptional pt;} related representative results showed shown site stamens syncarpy, test transformants transgenic transition transitions work


HC + 3wks
Front end forum
## Lineup
* Trials & tribulations with AngularJS
* Choosing a UI framework/library
* Discussion of top UI framework/libraries
* Fanboy's demo of Google PaaS (App Engine)
Trials & tribulations with AngularJS
Shane Bell
In this talk we examine practical use of AngularJS in various scenarios.
Choosing a UI framework/library
Mikkel Bergmann
In this talk we examine what considerations both the business and a developers should examine when choosing a new UI framework.
Framework or library
## With great power...
* If you choose a library, it is your _[responsibility](resource/img/with-great-power-weeee.gif)_ to implement [the other parts](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller)
* If you choose a framework, it will _enforce_ a particular implementation
## How to evaluate?
* **Objective** - measurable attributes for a library/framework, eg: production install base
* **Subjective** - opinion based attributes of a library/framework, eg: developer sentiment
## Objective considerations
* **Popularity** - eg: how many stars does it have on Github?
* **Integrations** - eg: how many offical integrations are available with other frameworks
* **Level** of control - eg: browser compatibility
* **Overheads** - eg: how large is a typical CSS/JS download for the library/framework
## Subjective considerations
These are based on a small team
* **Maintainable** - how easy is it for a developer to modify and keep the UI up to date whilst adhering to coding standards?
* **Expressive** - how quickly can a developer get a new solution out the door?
* **Performant** - how well does the UI perform in complex situations?
A general observation about UI frameworks
- If a framework is Maintainable and Performant, it won't be Expressive
- If a framework is Maintainable and Expressive, it won't be Performant
- If a framework is Performant and Expressive, it won't be Maintainable
Pick any two
Discussion of top UI framework/libraries
Mikkel Bergmann
Here we will evaluate the top 3 UI framework/libraries in a fastidius yet logical manner.
Fanboy's demo of Google PaaS (App Engine)
Andrew Walker
In this talk we will look at how the pros use Google App engine to the fullest extent.
Tip of the month
Open the chomre development tools, press F8 at any time to pause at the next JS execution!
Thanks for coming!
If you are interested in presenting a lightning talk, please let me know for next month.


Copy a file, converting and formatting according to the operands.
bs=BYTES read and write up to BYTES bytes at a time
cbs=BYTES convert BYTES bytes at a time
conv=CONVS convert the file as per the comma separated symbol list
count=N copy only N input blocks
ibs=BYTES read up to BYTES bytes at a time (default: 512)
if=FILE read from FILE instead of stdin
iflag=FLAGS read as per the comma separated symbol list
obs=BYTES write BYTES bytes at a time (default: 512)
of=FILE write to FILE instead of stdout
oflag=FLAGS write as per the comma separated symbol list
seek=N skip N obs-sized blocks at start of output
skip=N skip N ibs-sized blocks at start of input
status=WHICH WHICH info to suppress outputting to stderr; 'noxfer' suppresses transfer stats, 'none' suppresses all
N and BYTES may be followed by the following multiplicative suffixes: c =1, w =2, b =512, kB =1000, K =1024, MB =1000*1000, M =1024*1024, xM =M GB =1000*1000*1000, G =1024*1024*1024, and so on for T, P, E, Z, Y.
Each CONV symbol may be:
ascii from EBCDIC to ASCII
ebcdic from ASCII to EBCDIC
ibm from ASCII to alternate EBCDIC
block pad newline-terminated records with spaces to cbs-size
unblock replace trailing spaces in cbs-size records with newline
lcase change upper case to lower case
ucase change lower case to upper case
sparse try to seek rather than write the output for NUL input blocks
swab swap every pair of input bytes
sync pad every input block with NULs to ibs-size; when used with block or unblock, pad with spaces rather than NULs
excl fail if the output file already exists
nocreat do not create the output file
notrunc do not truncate the output file
noerror continue after read errors
fdatasync physically write output file data before finishing
fsync likewise, but also write metadata
Each FLAG symbol may be:
append append mode (makes sense only for output; conv=notrunc suggested)
direct use direct I/O for data
directory fail unless a directory
dsync use synchronized I/O for data
sync likewise, but also for metadata
fullblock accumulate full blocks of input (iflag only)
nonblock use non-blocking I/O
noatime do not update access time
nocache discard cached data
noctty do not assign controlling terminal from file
nofollow do not follow symlinks
count_bytes treat 'count=N' as a byte count (iflag only)
skip_bytes treat 'skip=N' as a byte count (iflag only)
seek_bytes treat 'seek=N' as a byte count (oflag only)
Sending a USR1 signal to a running 'dd' process makes it print I/O statistics to standard error and then resume copying.
f(CW$ dd if=/dev/zero of=/dev/null& pid=$!
f(CW$ kill -USR1 $pid; sleep 1; kill $pid
18335302+0 records in 18335302+0 records out<PHONE_NUMBER> bytes (9.4 GB) copied, 34.6279 seconds, 271 MB/s
Options are:
--help display this help and exit
--version output version information and exit
Written by Paul Rubin, David MacKenzie, and Stuart Kemp.
GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
Report dd translation bugs to <http://translationproject.org/team/>
Copyright © 2014 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.
Full documentation at: <http://www.gnu.org/software/coreutils/dd>
or available locally via: info (aq(coreutils) dd invocation(aq


CarHouse
Error
404
The page you were looking for was moved
or it never existed.
You can return to
the home page
or
choose a new car


--- title: "Garden After Dark Contest" layout: "default" ---
While at Garden After Dark you may choose an Oz figure at the Emerald City to take home and decorate yourself using at least one natural material like an acorn cap, flowers, or a leaf. Snap a picture of your completed masterpiece and send it to us. One lucky entry in each category will win an Oz-some prize package. What will you create?
Complete the CRAFTING CONTEST ENTRY FORM online and submit a photo of your creation by November 8, 2019. Images will be shared on the Garden’s social media channels.
Keep count of the Flying Monkeys you find hidden throughout Oz. Enter your guess online at FLYING MONKEYS ENTRY FORM to be entered to win one of six FREE Family or Circle of Friends Memberships to Red Butte Garden.
BEST IN SHOW
FIRST PLACE (One per character type)


motif-shuffle-columns [options] <motif file>+
Creates motifs from the shuffled columns of the input motifs.
The names of one or more files containing motifs in MEME format.
Outputs a minimal meme format file containing motifs of the same sizes using all the columns from the original files shuffled around into different motifs and column positions.
By default the output is written to standard output.
| Option | Parameter | Description | Default Behavior |
|---|---|---|---|
| General Options | |||
| -o | file name | Sets the output file name. | The output is written to standard output. |
| -seed | seed | Sets the pesudo-random number generator's seed. | The psudo-random number generator is seeded from the system random number generator. |