Close the client. Closing will close down any pooled connections. Clients should always be closed after use.
Create an HTTP DELETE request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP DELETE request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP DELETE request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create an HTTP GET request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP GET request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP GET request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create an HTTP HEAD request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP HEAD request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP HEAD request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create an HTTP PATCH request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP PATCH request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP PATCH request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP PATCH request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create an HTTP POST request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP POST request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP POST request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create an HTTP PUT request to send to the server at the default host and port.
the relative URI
an HTTP client request object
Create an HTTP PUT request to send to the server at the specified host and port.
the port
the host
the relative URI
an HTTP client request object
Create an HTTP PUT request to send to the server at the specified host and default port.
the host
the relative URI
an HTTP client request object
Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
the absolute URI
an HTTP client request object
Create a request with a custom HTTP method to send to the server at the default host and port.
custom HTTP Method
the relative URI
an HTTP client request object
Create a request with a custom HTTP method to send to the server at the specified host and port.
custom HTTP Method
the port
the host
the relative URI
an HTTP client request object
Create a request with a custom HTTP method to send to the server at the specified host and default port.
custom HTTP Method
the host
the relative URI
an HTTP client request object
Create a request with a custom HTTP method to send to the server using an absolute URI, specifying a response handler to receive the response
custom HTTP Method
the absolute URI
an HTTP client request object
Create an HTTP request to send to the server at the specified host and port.
the HTTP method
the port
the host
the relative URI
an HTTP client request object
Like {@link #request(HttpMethod, int, String, String)} using the {@code serverAddress} parameter to connect to the server instead of the {@code port} and {@code host} parameters.
The request host header will still be created from the {@code port} and {@code host} parameters.
Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
Create an HTTP request to send to the server at the specified host and default port.
the HTTP method
the host
the relative URI
an HTTP client request object
Like {@link #request(HttpMethod, String, String)} using the {@code serverAddress} parameter to connect to the server instead of the default port and {@code host} parameter.
The request host header will still be created from the default port and {@code host} parameter.
Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
Create an HTTP request to send to the server at the default host and port.
the HTTP method
the relative URI
an HTTP client request object
Like {@link #request(HttpMethod, String)} using the {@code serverAddress} parameter to connect to the server instead of the default port and default host.
The request host header will still be created from the default port and default host.
Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
Create an HTTP request to send to the server at the specified host and port.
the HTTP method
the request options
an HTTP client request object
Like {@link #request(HttpMethod, RequestOptions)} using the {@code serverAddress} parameter to connect to the server instead of the {@code options} parameter.
The request host header will still be created from the {@code options} parameter.
Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
Create an HTTP request to send to the server using an absolute URI
the HTTP method
the absolute URI
an HTTP client request object
Like {@link #requestAbs(HttpMethod, String)} using the {@code serverAddress} parameter to connect to the server instead of the {@code absoluteURI} parameter.
The request host header will still be created from the {@code absoluteURI} parameter.
Use {@link SocketAddress#domainSocketAddress(String)} to connect to a unix domain socket server.
Create a web client using the provided {@code vertx} instance and default options.
the vertx instance
the created web client
Create a web client using the provided {@code vertx} instance.
the vertx instance
the Web Client options
the created web client
Wrap an {@code httpClient} with a web client and default options.
the {@link HttpClient} to wrap
the web client
Wrap an {@code httpClient} with a web client and default options.
Only the specific web client portion of the {@code options} is used, the {@link io.vertx.core.http.HttpClientOptions} of the {@code httpClient} is reused.
the {@link HttpClient} to wrap
the Web Client options
the web client
Generated using TypeDoc
An asynchronous HTTP / HTTP/2 client called {@code WebClient}.
The web client makes easy to do HTTP request/response interactions with a web server, and provides advanced features like:
The web client does not deprecate the {@link HttpClient}, it is actually based on it and therefore inherits its configuration and great features like pooling. The {@code HttpClient} should be used when fine grained control over the HTTP requests/response is necessary.
Julien Viet


Use the Templates/Profiles page to view a list of CDA, HQMF and E-Measure templates and FHIR profiles. Use the View Template/Profile page to view the template/profile details.
Viewing a Template/Profile
There are two ways to view a template/profile:
- From the Implementation Guides list
- From the Templates/Profiles list
View a Template/Profile from the Implementation Guides List
- From the Browse menu, choose Implementation Guides.
- Use the Trifolia's Automatic Lookup feature to find the implementation guide containing the template/profile you want to view. A list of implementation guides that match your search criteria appears.
- In the implementation guides list, select View for the implementation guide you want to view.The implementation guide appears, showing you a list of templates/profiles contained in the guide.
- Review the list of templates for the type of template you want to view. Locate the template/profile you want to view and select View. The template/profile viewer opens, containing the template/profile details.
View a Template/Profile from the Templates List
- From the Browse menu, choose Templates/Profiles.
- Use the Trifolia's Automatic Lookup feature to find the templates/profiles you want to browse. A list of templates/profiles that match your search criteria appears.
- In the Template/Profile list, choose View for the desired template/profile. The template/profile viewer opens, containing the template/profile details.
Viewing the Template/Profile
- Constraints - View a list of the template/profile's constraints as they appear in the implementation guide.
- Samples - View a code sample attached to the template/profile. The "Samples" tab does not appear in the template/profile viewer if no samples exist for the template/profile.
- Relationships - View the relationship of the current template/profile to other templates/profiles.
- Implied By the current template/profile - lists any templates/profiles that reference the current template/profile
- Contains a template/profile - lists any templates/profiles contained within constraints in the current template/profile
- Contained By a template/profile - lists any templates/profiles that reference the current template/profile
- Implies a template/profile - lists a single template/profile referenced in the Implies field of the current template/profile
- Changes - View changes to the template/profile. View the changes Inline or as a List. (See below)
Viewing Changes - List
When you view changes to a template/profile as a List, each constraint change is listed in a table. The type of change is listed as:
Notes:
- Unchanged constraints do not appear in the list.
- Each entry contains the constraint reference number, the old narrative, and the new narrative.


What I'm up to?
In the IT field, there are many strong opinions for and against cloud computing. But what is the fuss all about? Is it actually worth it? Are some better than others? If you open a YouTube video that even touches the subject of cloud computing, you will find people on the comments section typing either A) Cloud is the worst thing ever created or B) Cloud is magical. Reality check: It isn't either. Why?
Cupcake ipsum dolor. Sit amet caramels carrot cake dragée bonbon sugar plum caramels cupcake. Marshmallow bonbon jelly. Chocolate bar powder cupcake halvah marshmallow gummies marshmallow. Halvah oat cake I love bear claw dragée chocolate chocolate I love sweet roll. Sesame snaps I love pastry.


Build Better Web Apps and Software with This Full-Featured API Tool for Mac: $21.24
by Bryan ChaffinWe have a deal on Paw, a full-featured HTTP client that lets you test and describe the APIs you build or consume. It features a native macOS interface to compose requests, inspect server responses, generate client code and export API definitions. Paw is $24.99 through our deal, but coupon code BFSAVE15 brigs it down to $21.24 at checkout.
Check It Out: Build Better Web Apps and Software with This Full-Featured API Tool for Mac: $21.24


i am deep
About Ta Liwa
I have always loved house music since I could even remember, which inspired me to pursue Dj'ing and that all began in 2011. As predicted I enjoyed it merely because of my love for music.
I wanted people to listen to something different for a change and not the predictable common House music which was my own sound. I started producing music in 2012 and have released 3 singles since then.
My goal for the near future is to produce more good music and mix monthly episodes of my own.


Create an artist website with a store, blog , galleries and much more with IndieMade's easy website builder


Wray, Percy Lassau
| Birth Name | Wray, Percy Lassau |
| Gender | male |
| Age at Death | 80 years, 16 days |
Narrative
3/7/2003 looked at Federation Series Index 1889 to 1918 no Percy Wray mentioned.
looked at Between Wars " " 1919/1945 - found marriages for:-
Percy in 1923, Beryl in 1944, and Peggy in 1945.
looked at - 1925 Electoral Rolls for Division 7 for Dalley & Cook, 8 for Wentworth also South Sydney, East Sydney, & West Sydney, couldn't find Percy
at all found plenty of Wray's. Found a Martha Victoria Wray at 17 Bennett St,
Camperdown, Home Duties.
4/10/2004 Wilma rang - she wants me to look for a marriage on St.Catherines for Percy to Martha Victoria ???, no luck, plenty of Percy's but NO Martha Victoria's. 10/10/2004 Wilma rang - she has found Percy marrying Martha Victoria Read in Vic in 1907. She also found they had two children, Dorothy in 1907 & Ronald in 1908.
SMH - WRAY, Percy Lassau - 3 November, 1968, at his residence, Bronte Rd, Bronte, dearly loved husband of Isabel, loved father of Beryl & Peggy, fond father-in-law of Allan & Maurie, dear grandfather of Lorraine, Barbara, Carolyn, Denise & Kewnneth, aged 80 years. Privately cremated.
Events
| Event | Date | Place | Description | Sources |
|---|---|---|---|---|
| Birth | 1888-10-18 | Norwood,South Australia | ||
|
|
||||
| Death | 1968-11-03 | Bronti Rd, Bronti NSW Aust | ||
|
|
Parents
| Relation to main person | Name | Birth date | Death date | Relation within this family (if not by birth) |
|---|---|---|---|---|
| Father | Wray, Frederick (Draper) | 1853 | 1933-08-30 | |
| Mother | Lassau, Wilhelmine Mathilda | 1853-10-21 | 1945-06-29 | |
| Brother | Wray, Frederick Renfrew “Renny” | 1880-04-03 | 1963 | |
| Brother | Wray, Milroy Roslyn | 1882-12-02 | 1947 | |
| Sister | Wray, Mathilda Amalie Gertrude | 1884-08-12 | 1887 | |
| Wray, Percy Lassau | 1888-10-18 | 1968-11-03 | ||
| Sister | Wray, Myrtle Ivy | 1892-05-18 | 1980 | |
| Brother | Wray, Oliver Sydney | 1894-04-24 | 1895-10-18 | |
| Brother | Wray, Walter Douglas | 1897-01-26 | 1986-09-28 |
Families
Family of Wray, Percy Lassau and Hewins, Isabel |
|||||||||||||||||||||||||
| Married | Wife | Hewins, Isabel ( * 1900-02-22 + 1985-01-19 ) | |||||||||||||||||||||||
|
|||||||||||||||||||||||||
| Children |
| Name | Birth Date | Death Date |
|---|---|---|
| Wray, [Living] | ||
| Wray, [Living] |
| Type | Value | Notes | Sources |
|---|---|---|---|
| _UID | 5B09FB65E5C4D5119853B7EB0FA9CA6DCF43 |
Family of Wray, Percy Lassau and Read, Martha Victoria
| Event | Date | Place | Description | Sources |
|---|---|---|---|---|
| Divorce | Y | |||
|
|
||||
| Marriage | 1907 | Victoria Aust | ||
|
|
| Name | Birth Date | Death Date |
|---|---|---|
| Wray, Dorothy Mildred | 1907 | |
| Wray, [Living] |
| Type | Value | Notes | Sources |
|---|---|---|---|
| _UID | C82BAD55FBBED7119853E84DA61F80736E17 |
Attributes
| Type | Value | Notes | Sources |
|---|---|---|---|
| _UID | 5A09FB65E5C4D5119853B7EB0FA9CA6DCE33 |


{% extends "djtracker/base.html" %} {% load i18n %} {% block content %}
{% blocktrans %}You may now browse the site. You may need to ask your administrator to assign you to necessary groups to browse certain projects however.{% endblocktrans %}
{% endblock %}


Please note that this is a early reference guide, and has evolved since it was published, but in combination with the SDK code should give plenty of hints as to how to work with the SDK in a low level.
A reference application shall be built to prove the concepts and APIs outlined above. This reference application will be implemented on the current range of platforms aimed at providing IoT services. These boards are typically running ‘M’ class processors which as yet do not contain an SE. Currently only the application processors (A class such as A57 Cortex) contain SEs. However developments are being made in the IoT platform space, for example ARM has released a new M architecture with does contain an SE , although there will be delay before boards using these processors and compiler tools become mainstream. This document requires these more secure platforms to be available.
{ "DeviceDescription": "Worldpay Within Enabled Electric Car Charger", "Hostname": "<IP_ADDRESS>", "PortNumber": 8800, "ServerID": "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "UrlPrefix": "v1/carcharge" }
In order to build the URL, use the hostname, with the port number, the url prefix all concatenated. The concatenate with “service/discover”.
http://<IP_ADDRESS>:8800/v1/carcharge/service/discover
{ }
Note: body content empty, request is direct to server indicated in broadcast.
{ "ServerID": "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "Services": [ { "ServiceID": 0, "ServiceDescription": "Car charging" }, { "ServiceID": 1, "ServiceDescription": "Car parking" } ] }
In order to build the URL, use the hostname, with the port number, the url prefix all concatenated. The concatenate with “service” concatenated with “service ID” and then “prices”.
http://<IP_ADDRESS>:8800/v1/carcharge/service/0/prices
{ }
Note: body content empty. URL includes the serviceID (i.e. 0) for the prices being requested, e.g. for serviceID 1, URL would be /v1/carcharge/service/1/prices)
{ "ServerID" : "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "Prices" : [{ "ServiceID" : 0, "PriceID" : 0, "PricePerUnit" : 140, "UnitID" : 0, "UnitDescription" : "kW", "PriceDescription" : "Slow (3.6kWh)" }, { "ServiceID" : 0, "PriceID" : 1, "PricePerUnit" : 70, "UnitID" : 0, "UnitDescription" : "kW", "PriceDescription" : "Medium (7.2kWh)" }, { "ServiceID" : 0, "PriceID" : 2, "PricePerUnit" : 10, "UnitID" : 0, "UnitDescription" : "kW", "PriceDescription" : "Super (120kWh)" } ] }
In order to build the URL, use the hostname, with the port number, the url prefix all concatenated. The concatenate with “service” concatenated with “service ID” and then “requestTotal”.
http://<IP_ADDRESS>:8800/v1/carcharge/service/0/requestTotal
Content: { "ClientID":"54560ba2-87c0-4172-a904-67a9b7a5e1ee", "SelectedNumberOfUnits":8, "SelectedPriceID":1 }
{ "ServerID": "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "ClientID": "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "PriceID": 1, "UnitsToSupply": 8, "TotalPrice": 560, "PaymentReferenceID": "e7c18800-706d-4f0c-933c-19f8d5be72da", "MerchantClientKey": " T_C_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx " }
HTTP POST to https://api.worldpay.com/v1/tokens. No custom HTTP headers used.
{ "clientKey" : "T_C_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "paymentMethod" : { "cardNumber" : "1234567890124444", "expiryMonth" : 2, "expiryYear" : 2021, "name" : "Bilbo Baggins", "type" : "Card" }, "reusable" : false }
{ "token": "TEST_SU_yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy", "paymentMethod": { "type": "ObfuscatedCard", "name": "Bilbo Baggins", "expiryMonth": 2, "expiryYear": 2021, "cardType": "MASTERCARD_CREDIT", "maskedCardNumber": "**** **** **** 4444", "cardSchemeType": "consumer", "cardSchemeName": "MCI CREDIT", "cardIssuer": "LLOYDS BANK PLC", "countryCode": "GB", "cardClass": "credit", "cardProductTypeDescNonContactless": "MasterCard Business", "cardProductTypeDescContactless": "CL MasterCard Bus", "prepaid": "unknown" }, "reusable": false }
HTTP POST to http://<IP_ADDRESS>:8800/v1/carcharge/payment
{ "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "ClientToken" : "TEST_SU_yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy ", "PaymentReferenceID" : "e7c18800-706d-4f0c-933c-19f8d5be72da" }
HTTP POST to https://api.worldpay.com/v1/orders. HTTP header includes the Merchant's Service Key (Private)
{ "amount" : 560, "currencyCode" : "GBP", "customerOrderCode" : "Car charge (8kW @ Medium (7.2kWh)) - 26\/01\/2016 15:40", "orderDescription" : "Car charging payment", "token" : "TEST_SU_yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy " }
{ "orderCode" : "4d22cb5d-5dfb-43ce-9108-dfe230151429", "token" : "TEST_SU_yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy ", "orderDescription" : "Car charging payment", "amount" : 560, "currencyCode" : "GBP", "paymentStatus" : "SUCCESS", "paymentResponse" : { "type" : "ObfuscatedCard", "name" : "Bilbo Baggins", "expiryMonth" : 2, "expiryYear" : 2021, "cardType" : "MASTERCARD_CREDIT", "maskedCardNumber" : "**** **** **** 4444", "cardSchemeType" : "consumer", "cardSchemeName" : "MCI CREDIT", "cardIssuer" : "LLOYDS BANK PLC", "countryCode" : "GB", "cardClass" : "credit", "cardProductTypeDescNonContactless" : "MasterCard Business", "cardProductTypeDescContactless" : "CL MasterCard Bus", "prepaid" : "unknown" }, "customerOrderCode" : "Car charge (8kW @ Medium (7.2kWh)) - 26/01/2016 15:40", "environment" : "TEST", "riskScore" : { "value" : "1" } }
{ "ServerID" : "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "TotalPaid" : 0, "ServiceDeliveryToken" : "3e7b4c25-157d-4b47-999c-e4faba086590", "client-uuid":"719D329B-8909-4A8B-B352-E449C3132074" }
HTTP POST to http://<IP_ADDRESS>:8800/v1/carcharge/service/0/delivery/begin
URL encodes the serviceID being requested
{ "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "ServiceDeliveryToken" : "3e7b4c25-157d-4b47-999c-e4faba086590", "UnitsToSupply" : 8 }
{ "ServerID" : "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "ServiceDeliveryToken" : "3e7b4c25-157d-4b47-999c-e4faba086590", "UnitsToSupply" : 8 }
HTTP POST to http://<IP_ADDRESS>:8800/v1/carcharge/service/0/delivery/end)
URL encodes the serviceID being requested
{ "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "ServiceDeliveryToken" : "3e7b4c25-157d-4b47-999c-e4faba086590", "UnitsReceived" : 8 }
{ "ServerID" : "58d8f9fb-b3e9-45bc-b701-fcdd295bc265", "ClientID" : "54560ba2-87c0-4172-a904-67a9b7a5e1ee", "ServiceDeliveryToken" : "3e7b4c25-157d-4b47-999c-e4faba086590", "UnitsJustSupplied" : 8, "UnitsRemaining" : 0 }


Palo Alto Networks Lambda Functions for ELB AutoScale Deployment¶
The Lambda Functions implemented and published by Palo Alto Networks are meant to work in conjunction with the ELB Auto Scaling Deployment on AWS.
At a high level, the goal of the lambda functions is to perform the initial setup and the plumbing necessary to allow traffic from the internet (untrust subnet) to the backend web tier (trust subnet) via the Palo Alto Networks Next Generation Firewall. The policies on the PAN NGFW determine the traffic that will be permitted to pass between the untrust and trust subnets. Additionally, the lambda functions also handle the various actions required when various events, such as autoscaling, occur which require the manipulation of the firewalls.
Use Cases¶
- Deploy Palo Alto Networks Next Generation Firewall in an auto scale configuration to handle unpredictable traffic patterns (spikes etc).
- Deploy best practice architectures to secure multi-tier applications on AWS with Palo Alto Networks Next Generation Firewalls.
AWS Specific Deployment Options¶
- Palo Alto supports the ELB architecture to be deployed with optional NAT Gateways fronting back end infrastructure. The advantage of this configuration is to not require publicly routable IP addresses for various instances in the absence of the NAT gateway.
- Alternatively, the ELB architecture can be deployed without NAT Gateways, in which case, public IP addresses will be created and assigned to the various nodes.
Lambda function objectives¶
- Deploy ASG’s and Bootstrap the Firewalls.
- Deploy Lambda Functions to monitor the VIP’s on the ILB.
- Program the NAT rules on the PAN FW
- Handle Auto Scale Events and take the necessary actions.
- Handle the de-licensing of Firewalls when they are deleted.
Theory of Operation¶
There are 4 main lambda functions that get deployed:
- init
- add_eni
- sched_evt1
- metrics
The two lambda functions that get deployed by the CFT are the first two listed above.
Init Lambda Function
The InitLambda lambda function is responsible for the following functions: - deployment and configuration of the
`sched_evt1`
lambda function - handling creation, update and delete of the cloud formation template - validating the AMI-ID’s of the PAN FW specified by the userWhen the init lambda function is triggered it validates that the AMI-ID of the PAN FW is valid and then proceeds to deploy the
`sched_evt1`
lambda function with all the required parameters. It should also be noted that the`sched_evt1`
lambda function is configured to be triggered every minute. The rationale for the frequency is provided in the next section.
Sched_evt1 Lambda Function
The primary objective of this lambda function is to probe (or describe / list) the IP addresses configured on the ILB, and for each and every IP address ensure that there is a corresponding ASG deployed. Conversely, if there exists an ASG without a corresponding IP address, the lambda function will delete the ASG.
When a new ASG is created, callbacks to handle life-cycle hooks are also configured. Enabling the life-cycle hooks allows for the
`add_eni`
lambda function to take various actions depending upon the life cycle action. The specific actions taken will be described in the section which describes the`add_eni`
lambda function description.
Add_ENI Lambda Function
The
`add_eni`
lambda function gets invoked by a life-cycle hook trigger. The lambda function gets triggered when an instance in an ASG either launches or terminates. When handling an instance launch life-cycle hook action, the lambda function creates and attaches ENI’s for the management and trust subnets. The lambda function is also responsible for the creation Elastic IP’s if necessary and attaching the EIP’s to the ENI’s.Additionally, this lambda function also creates or deletes, as the case maybe, the
`metrics`
lambda function. The details of the`metrics`
lambda function are described below.
Metrics Lambda Function
The`metrics`
lambda function is configured to be invoked every second. The objective of this function is to query the firewalls for various defined metrics via the XML API. The metrics retrieved from the firewall are subsequently consumed by the AWS Auto Scaling framework, in order to make decisions with regard to either keeping the number of firewalls constant, or increasing or decreasing the number of firewalls as the case maybe.
Availability Zones¶
The ELB Autoscale Deployments require at a minimum two availability zones to be deployed into. Consequently, the lambda functions will spin up auto scale groups to match the desired capacities in all of the specified availability zones.
Auto Scaling Parameters¶
Autoscaling on AWS occurs by defining and advertising the parameters that will be used by the AWS framework to make auto scaling decisions. The parameters currently defined are:
- ActiveSessions
- DataPlaneBufferUtilization
- DataPlaneCPUUtilization
- GPGatewayUtilization
- SessionUtilization
The AWS requires users to specify a `high`
threshold and a `low`
threshold for each parameters. When one of the
parameters breaches the high threshold mark, a scale out event is triggered. Consequently, when one of the parameters
breaches the low threshold mark, a scale in event is triggered.
Panorama¶
The use of a Panorama is optional along with the autoscaling deployment. However, it is possible to associate
a firewall with the Panorama. Panorama configuration parameters such as the IP among others can be specified
in the `init-cfg`
file.
Logging¶
The logs from the lambda functions are available as Cloud Watch Logs. Log groups are created on cloud watch, which are prepended with the stack name.
Note
The logging level for the CFT stack can be modified in the following manner:
- Create a queue on SQS, and name it with the stack name
- Send a message with the desired logging level.
Inputs to the Lambda Functions¶
Identify the various deployment artifacts such as:
- ServiceToken
- StackName
- Region
- VPCID
- SubnetIDMgmt
- SubnetIDUntrust
- SubnetIDTrust
- MgmtSecurityGroup
- UntrustSecurityGroup
- TrustSecurityGroup
- VPCSecurityGroup
- KeyName
- ELBName
- ILBName
- FWInstanceType
- SSHLocation
- MaximumInstancesASG
- ScaleUpThreshold
- ScaleDownThreshold
- ScalingParameter
- ScalingPeriod
- ImageID
- LambdaENISNSTopic
- MinInstancesASG
- FirewallBootstrapRole
- LambdaExecutionRole
- ASGNotifierRole
- ASGNotifierRolePolicy
- MasterS3Bucket
- PanS3BucketTpl
- PanS3KeyTpl
- KeyPANWFirewall
- KeyPANWPanorama
- NATGateway
- SubnetIDNATGW
- SubnetIDLambda
- AddENILambda
- InitLambda
- Version
- KeyDeLicense
- LambdaENIQueue


# of Checkpoints:
{{game.nodeCount}}
Rating:
(out of {{game.numOfRatings}} reviews)
Created on:
{{game.createdDate | date : 'MM/dd/yyyy' }}
Game Description:
{{game.description}}


Relief | Recovery | Resiliency
Centralized information of the issues & initiatives from Puerto Rico
Island Recovery Plans & Engagement
This document provides a high level and non-exhaustive overview of the issues and initiatives that have arisen in response to the impact of hurricanes Maria and Irma on Puerto Rico. The efforts of relief, recovery, and resiliency are often overlapping and should not be looked at as a sequential guide.
Initiatives
Below are a list of the initiatives by category. See what people are doing, and find out the best way you can help.
Relief
Recovery
Resilience
What are the initiatives ?
This a recognizable non-profit organizations dedicated to the immediate and long term relief efforts in Puerto Rico. Here is a list of the organizations with initiatives:


---
layout: post
title: ! 'Handy Hack: Installing Ubuntu 8.10 on EEE PC 1000H'
tags:
- EEE PC
- LinkedIn
- Linux
status: publish
type: post
published: true
meta:
_edit_last: '451289'
---
The 10" EEE PC 1000H makes a good choice for people looking for a notebook with a little more storage and bigger keyboard than Asus' previous model. Unfortunately, whilst the local Harvey Norman had a good price, I was still forced to pay the Microsoft tax. So the third job after I got home (after upgrading the BIOS and checking the hardware worked ) was to install Ubuntu 8.10. The process was pretty straight forward because I had a current Ubuntu system to create the USB boot disk and a wired network connection so that I could install the wireless tweaks. However it took a fair mount of Googling to hopefully this should save some folks a bit of time.
- Get a copy of the 32-bit Ubuntu 8.10 ISO image. I used the Desktop version, alternative should work fine as well
- Use the Ubuntu System->Administration -> Create Startup USB tool to copy Ubuntu to a USB stick
- Shutdown Windows on the EEE. I had to do this via Windows shutdown to get the correct prompts on power up
- Power up the EEE with the ESC key pressed. You should be prompted for a boot device
- Boot from USB
- Install Ubuntu in the normal fashion
- Connect to wired Internet connection
- Get latest updates
- Follow these instructions
- You should now have a working EEE PC with wireless
To configure Evolution email use ALT-f at the end of each configuration screen (the buttons can't be seen)
Try setting the panels to autohide this will give you a little more screen room
The EEE PC trackpad buttons are pushed from the front by the way, not the top.


Hi Welcome
I`am Eka Gans
My WhatsApp
Calculator
I Love you
Ph Logo
TicTacToe
Winrate
Dino Run
Rest API
Thanks for : JarXr - Fdhlgrphy - RizkyFadilah - Caliph71 - And My Friends


Ambidexterity
Learn to effectively use two weapons and attack with both at the same time.{^n}{^y}Requires dual-wield.
Dual Wield Only, Sword, Axe, Mace, Thrown Weapon
${value}% Chance to be Used
12 14 16 18 20 22 24 26 28 30
Launches ${value} Projectile(s)
1
${value} Physical Damage
min: [5.0, 9.0, 14.0, 20.0, 25.0, 29.0, 34.0, 38.0, 43.0, 47.0]
MaxLevel
6
UltimateLevel
10


Selector ::= SelectorElement*
no references
referenced by:
::= '>' ElementMatcher
referenced by:
::= '~' ElementMatcher
referenced by:
referenced by:
::= Char* ( '{' Expression '}' )?
referenced by:
::= '*' ( '{' Expression '}' )?
referenced by:
::= TODO
referenced by:
|
|


Dave Grohl Joins Big Bird And Elmo For ‘Sesame Street’ Travelling Song
by Brent FurdykDave Grohl has just hit the street — “Sesame Street”, that is, with the Foo Fighters frontman dropping in for a special song with Elmo and Big Bird.
In a new video shared by the beloved children’s TV show, Elmo introduces his “friend, Mr. Dave Grohl,” for a song titled “Here We Go”.
“It’s nice to come here and be with my friends Big Bird and Elmo,” Grohl tells the duo.
In the video, the trio is seen travelling throughout the U.S. to meet new friends — through the magic of green screen, of course — while Elmo even gets to show off his guitar skills.
This isn’t the first time that Grohl has spent time with Muppets; not only did he appear in the 2011 feature film “The Muppets” (playing Animal’s replacement in a Muppets cover band called The Moopets), he also faced off with Animal in an epic drum battle during an appearance on ABC’s short-lived 2015 series “The Muppets”. Watch:


2048
Java Web API
SCORE
0
New Game
Game Over
HOW TO PLAY:
Use
arrow keys
to move the tiles. Two tiles of the same number will
merge into one!
Last Request:
Last JSON Response:
j
Created by
Alan Rusnak
.
View source code on GitHub.
Inspired by
2048 by Gabriele Cirulli.


I've had a lot of math since the idea of completing the square was first introduced to me, and while comparatively a simple matter, I've always found it a difficult concept to grasp and a difficult process to recall. It turns out that the algebraic process is rooted in geometry.
Completing the square is the process of converting a quadratic equation of the form
\[ax^2 + bx + c = 0\]
to the (easier to solve) form
\[a(x + d)^2 + e = 0\]
where \(d = \frac{b}{2a}\), and \(e = c - \frac{b^2}{4a}\).
The purpose of this post is to intuitively explain where the values of \(d\) and \(e\) come from.
Suppose we have \(x^2 + 10x = 39\). We want to find \(x\), but our equation doesn't factor easily, and we can't really move things around to make it easier to work with. We need to do something else.
Before we get to solving it, let's look at how we might represent \(x^2\) geometrically. For the hell of it let's represent \(x^2\) as a square with dimensions \(x\) by \(x\). We'll display the dimensions next to their corresponding sides for clarity.
| \(x\) | |
| \(x\) | \(x^2\) |
Similarly, let's represent \(10x\) as a rectangle with dimensions \(10\) by \(x\).
| \(x\) | |
| \(10\) | \(10x\) |
Note that this \(10x\) rectangle is equivalent with two \(5\) by \(x\) rectangles. Splitting this
rectangle into two pieces is a
frivolously contrived
ingenious move that will allow us to do what's called
completing the square
.
| \(x\) | |
| \(10\) | \(10x\) |
| \(=\) |
| \(x\) | |
| \(5\) | \(5x\) |
| \(+\) |
| \(x\) | |
| \(5\) | \(5x\) |
Using this, let's represent \(x^2 + 10x = 39\) geometrically by attaching the corresponding rectangles to each other. We lay the left hand side out in this manner for the hell of it, totally not knowing that doing so is a key maneuver for what's next.
| \(x\) | \(5\) | |
| \(x\) | \(x^2\) | \(5x\) |
| \(5\) | \(5x\) |
| \(=\) |
| \(39\) |
This ugly representation of our equation tantalizingly suggests our next step. Let's complete the square by adding the missing part of the square on the left. It feels natural, right? From the dimensions displayed on the outside edge of our rectangles we know the size of the missing square to be \(5\) by \(5\), or \(25\).
| \(x\) | \(5\) | |
| \(x\) | \(x^2\) | \(5x\) |
| \(5\) | \(5x\) | \(25\) |
| \(=\) |
| \(39\) |
| \(+\) |
| \(25\) |
The square we've just created has dimensions of \((x+5)\) by \((x+5)\), and we know its area to be \(39+25\), or \(64\). We can therefore set up the equation \((x+5)^2 = 64\) as an algebraic representation of our squares.
| \(x+5\) | |||
| \(x+5\) | \(=\) | \(64\) |
We can use this much easier to solve equation to find \(x\).
\[(x+5)^2 = 64\]
Taking the square root of both sides, and being sophisticated students of mathematics we realize that both positive and negative \(8\) will satisfy \(\sqrt{64}\). This gives us
\[(x+5)=\pm8\]
which can be trivially solved to get \(x=3\) and \(x=-13\).
Now of course we could have used our old friend, the quadratic formula, which would have spat our solutions right out in our faces. This probably would have been much easier, but then we wouldn't have had to (gasp) think about the solution.
\[x=\frac{-b\pm\sqrt{b^2-4ac}}{2a}\]


cacertinmem.c
Download cacertinmem.c raw
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 1998 - 2018, Daniel Stenberg<EMAIL_ADDRESS>et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at https://curl.haxx.se/docs/copyright.html.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the COPYING file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
***************************************************************************/
/* <DESC>
* CA cert in memory with OpenSSL to get a HTTPS page.
* </DESC>
*/
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <curl/curl.h>
#include <stdio.h>
size_t writefunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
fwrite(ptr, size, nmemb, (FILE *)stream);
return (nmemb*size);
}
static CURLcode sslctx_function(CURL *curl, void *sslctx, void *parm)
{
CURLcode rv = CURLE_ABORTED_BY_CALLBACK;
X509_STORE *store = NULL;
X509 *cert = NULL;
BIO *bio = NULL;
char *mypem =
/* CA for example.com. CN = DigiCert High Assurance EV Root CA */
"-----BEGIN CERTIFICATE-----\n"
"MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs\n"
"MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n"
"d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j\n"
"ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL\n"
"MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3\n"
"LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug\n"
"RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm\n"
"+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW\n"
"PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM\n"
"xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB\n"
"Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3\n"
"hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg\n"
"EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF\n"
"MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA\n"
"FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec\n"
"nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z\n"
"eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF\n"
"hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2\n"
"Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe\n"
"vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep\n"
"+OkuE6N36B9K\n"
"-----END CERTIFICATE-----\n";
/* clear the current thread's OpenSSL error queue */
ERR_clear_error();
/* get a BIO */
bio = BIO_new_mem_buf(mypem, -1);
if(!bio)
goto err;
/* use it to read the PEM formatted certificate from memory into an X509
* structure that SSL can use
*/
if(!PEM_read_bio_X509(bio, &cert, 0, NULL))
goto err;
/* get a pointer to the X509 certificate store (which may be empty!) */
store = SSL_CTX_get_cert_store((SSL_CTX *)sslctx);
if(!store)
goto err;
/* add our certificate to this store */
if(!X509_STORE_add_cert(store, cert)) {
unsigned long error = ERR_peek_last_error();
/* Ignore error X509_R_CERT_ALREADY_IN_HASH_TABLE which means the
* certificate is already in the store. That could happen if
* libcurl already loaded the certificate from a ca cert bundle
* set at libcurl build-time or runtime.
*/
if(ERR_GET_LIB(error) != ERR_LIB_X509 ||
ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
goto err;
ERR_clear_error();
}
rv = CURLE_OK;
err:
if(rv != CURLE_OK) {
char errbuf[256];
unsigned long error = ERR_peek_last_error();
fprintf(stderr, "error adding certificate\n");
if(error) {
ERR_error_string_n(error, errbuf, sizeof(errbuf));
fprintf(stderr, "%s\n", errbuf);
}
}
X509_free(cert);
BIO_free(bio);
ERR_clear_error();
return rv;
}
int main(void)
{
CURL *ch;
CURLcode rv;
rv = curl_global_init(CURL_GLOBAL_ALL);
ch = curl_easy_init();
rv = curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
rv = curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
rv = curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1L);
rv = curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
rv = curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, *writefunction);
rv = curl_easy_setopt(ch, CURLOPT_WRITEDATA, stdout);
rv = curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, *writefunction);
rv = curl_easy_setopt(ch, CURLOPT_HEADERDATA, stderr);
rv = curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, "PEM");
rv = curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 1L);
rv = curl_easy_setopt(ch, CURLOPT_URL, "https://www.example.com/");
/* turn off the default CA locations (optional)
* otherwise libcurl will load CA certificates from the locations that
* were detected/specified at build-time
*/
rv = curl_easy_setopt(ch, CURLOPT_CAINFO, NULL);
rv = curl_easy_setopt(ch, CURLOPT_CAPATH, NULL);
/* first try: retrieve page without ca certificates -> should fail
* unless libcurl was built --with-ca-fallback enabled at build-time
*/
rv = curl_easy_perform(ch);
if(rv == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
/* use a fresh connection (optional)
* this option seriously impacts performance of multiple transfers but
* it is necessary order to demonstrate this example. recall that the
* ssl ctx callback is only called _before_ an SSL connection is
* established, therefore it will not affect existing verified SSL
* connections already in the connection cache associated with this
* handle. normally you would set the ssl ctx function before making
* any transfers, and not use this option.
*/
rv = curl_easy_setopt(ch, CURLOPT_FRESH_CONNECT, 1L);
/* second try: retrieve page using cacerts' certificate -> will succeed
* load the certificate by installing a function doing the necessary
* "modifications" to the SSL CONTEXT just before link init
*/
rv = curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, *sslctx_function);
rv = curl_easy_perform(ch);
if(rv == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
curl_easy_cleanup(ch);
curl_global_cleanup();
return rv;
}


If you’re a front-end developer, chances are you’ve worked with an API, whether it’s RESTful or not is another story that will not be addressed here. What I will discuss is how elegantly RESTful architecture makes backend to front-end relationship an ideal structure for development.
As a front-end developer at Columbia University, I’ve had the pleasure of working with other developers’ APIs. Now, the API might not be considered RESTful that we were working with (a level 1 or 2 on the Richardson Maturity Model) but the structure is close enough. The project allowed for me to focus solely on the user experience and design of the client side experience without having to worry about server side template rendering, using AngularJS as the front-end framework.
The API I was connecting to was populated with dummy data while he worked on writing the backend logic. As he finished the results changed organically as it was committed and pushed. But how is this better than the typical server-side template processing?
Well, for one the API creates a clear distinction between front-end and backend. When the templates are processed on the server side, developers can step on each other’s toes. In Drupal, for example, the addition of a module can change how some results are written completely, making the front-end dev adjust their code.
Another bonus for RESTful APIs is versioning. If major changes occur to the structure of the API, you can progress to another version number without retiring the old API until you’re ready. While this can be done with most LAMP frameworks, it’s a more convoluted process and again, messy.
Processing the templates on the client side saves you server processing resources. For large scale applications, this can mean hundreds of dollars. It also gives you more flexibility with scaling, letting your resources focus on the computations and leaving the client to render the aesthetics.


{% load static %}
Explore the map and use filters to find three organizations that are interesting to you.
Next, look up these organizations online. Take a few momements to review their websites. Then choose one organization that you are most interested in.
Dive a bit deeper into the organization (website, news reports, social media, etc.)
Take a look at the leadership and staff at the organization. Which staff member is best to connect with?


{% extends "base/2020/index.html" %} {% block title %}The {{ year }} Web Almanac{% endblock %} {% block description %}The Web Almanac is an annual state of the web report combining the expertise of the web community with the data and trends of the HTTP Archive.{% endblock %} {% block twitter_image_alt %}The {{ year }} Web Almanac{% endblock %} {% block date_published %}2020-07-06T00:00:00.000Z{% endblock %} {% block date_modified %}2020-07-11T00:00:00.000Z{% endblock %} {% block intro_title %}Coming soon!{% endblock %} {% block intro_sub_title %}The {{ year }} state of the web report{% endblock %} {% block mission %}
Experts from around the web community are currently hard at work planning, analyzing, and writing content for the {{ year }} edition of the Web Almanac, which is on track to be published at the end of the year.
There are many opportunities available for new contributors to join the project, including: authors, reviewers, analysts, editors, translators, and developers. If you're interested in contributing to the {{ year }} edition, we'd love to have you!
Join the team {% endblock %}


Health Camp SPA
Demographics
Health Vitals
Reports
Patient Details
No.
Name
Age
Gender
Photo
Medication
Notes


# Fire up dev tools and try: superheroes[0].name = "Wagner, Kurt"; superheroes.push({ name: "Wolverine" }); superheroes.length = 0;


Euro 2020 confusion reigns ahead of playoff draw
by BeSoccerThe draw for the Euro 2020 playoffs takes place in Nyon on Friday amid widespread confusion over the format and make up of the group stage for next year's finals.
The last four places in the tournament, which is being hosted in 12 cities, will be decided by March's playoffs, with its 16-team make-up based on performances in the recent inaugural UEFA Nations League.
That gives teams that failed in the main qualifying campaign a second chance to bag a spot, such as Northern Ireland and their neighbours the Republic of Ireland.
The Northern Irish will visit Bosnia and Herzegovina on March 26 while the Republic going to Slovakia the same day, with the winners of those one-off ties meeting five days later with a finals place at stake.
Scotland will have a home play-off against either Bulgaria, Israel, Hungary or Romania. Should they win that, they will then take on Norway or Serbia for a place in the finals.
However, Scotland, Hungary and Romania are all due to host matches next summer, creating a potential headache for organisers should they each qualify for the Euros.
The fact the play-off winners will not be known until just two and a half months before the start of the Euros on June 12, adds another layer of complication.
Meanwhile much of the suspense has already been removed from the draw for the finals, which is being held in Bucharest on November 30, as host nations have to play group games on home turf and certain teams need to be kept apart for geopolitical reasons.
Featured links
- BREAKING NEWS: Mourinho replaces Pochettino at Tottenham
- The latest football transfers news and rumours
- Wales, golf, Madrid... in that order
- Luis Enrique returns to Spain national team
Ukraine and Russia cannot face one another due to the conflict in eastern Ukraine.
That led to Kevin De Bruyne to call the format a "scandal", while Ronald Koeman, whose Netherlands team have already been placed in Group C with Ukraine, asked the Dutch FA if he could avoid travelling to next week's group stage draw.
Play-off line-up
Path A: Iceland plus three from Bulgaria, Israel, Hungary and Romania
Path B: Bosnia and Herzegovina v Northern Ireland; Slovakia v Republic of Ireland
Path C: Scotland v one of Bulgaria, Israel, Hungary or Romania; Norway v Serbia
Path D: Georgia v Belarus; North Macedonia v Kosovo
- Play-off draw to be held on Friday, November 22


Reports Area conditions & general observations
{{report.run_name}}
{{report.created_at | date: 'MMM d, y h:mm a'}}
Avalanche Sighted
{{report.new_snow}}'' of new snow
✕
{{report.description}}
Snow Quality: {{report.quality}}
- by {{report.username}}
Uh oh! Looks like this area lacks reports. Visit the 'Create Report' tab to contribute.


Hands on R
Posted on Wed 11 January 2017 in Data-Science
Basic Points
- Vector recycling !
- Function returns the last line
- Atomic vector is a simple vector of data.
- Each atomic vector stores its values as a one-dimensional vector, and each atomic vector can only store one type of data. You can save different types of data in R by using different types of atomic vectors. Altogether, R recognizes six basic types of atomic vectors: doubles, integers, characters, logicals, complex, and raw.
- floating-point errors?
- Raw vectors store raw bytes of data. Making raw vectors gets complicated, but you can make an empty raw vector of length n with raw(n). See the help page of raw for more options when working with this type of data:
- Attributes: An attribute is a piece of information that you can attach to an atomic vector (or any R object). The attribute won’t affect any of the values in the object, and it will not appear when you display your object. You can think of an attribute as “metadata”; it is just a convenient place to put information associated with an object. R will normally ignore this metadata, but some R functions will check for specific attributes. These functions may use the attributes to do special things with the data.
- NULL :NULL R uses NULL to represent the null set, an empty object. NULL is often returned by functions whose values are undefined. You can create a NULL object by typing NULL in capital letters.
- Names The most common attributes to give an atomic vector are names, dimensions (dim), and classes. Each of these attributes has its own helper function that you can use to give attributes to an object. You can also use the helper functions to look up the value of these attributes for objects that already have them.  For example, the die matrix is a special case of a double vector. Every element in the matrix is still a double, but the elements have been arranged into a new structure. R added a class attribute to die when you changed its dimensions. This class describes die’s new format. Many R functions will specifically look for an object’s class attribute, and then handle the object in a predetermined way based on the attribute.
-
Factors are R's way of storing categorical information.
> gender<-factor(c("male","female","trans"))
> attributes(gen
gender generic.skeleton
> attributes(gender)
$levels
[1] "female" "male" "trans"
$class
[1] "factor"
- R coercion? You may have guessed that this exercise would not go well. Each atomic vector can only store one type of data. As a result, R coerces all of your values to character strings:
card <- c("ace", "hearts", 1)
card
## "ace" "hearts" "1"
This will cause trouble if you want to do math with that point value, for example, to see
- In some cases, using only a single type of data is a huge advantage. Vectors, matrices, and arrays make it very easy to do math on large sets of numbers because R knows that it can manipulate each value the same way. Operations with vectors, matrices, and arrays also tend to be fast because the objects are so simple to store in memory. In other cases, allowing only a single type of data is not a disadvantage. Vectors are the most common data structure in R because they store variables very well. Each value in a variable measures the same property, so there’s no need to use different types of data.
- Data frame is a special type of list.
Data frames are the two-dimensional version of a list. They are far and away the most useful storage structure for data analysis, and they provide an ideal way to store an entire deck of cards. You can think of a data frame as R’s equivalent to the Excel spreadsheet because it stores data in a similar format. Data frames group vectors together into a two-dimensional table. Each vector becomes a column in the table. As a result, each column of a data frame can contain a different type of data; but within a column, every cell must be the same type of data, as in Figure 3-2. str() function. head() v/s tail() * Saving Data
write.csv(deck, file = "cards.csv", row.names = FALSE)
To sum it up
-
R Notation
-
Value selection in R. dataframe[i,j]. Negative values means exclusion. Blank space means all dimensions. Indexing with 0 returns an empty object.
- $ and [[]] do the same thing.
Difference :


[GSoC 2016] Introducing RCurry - An abstraction layer
Hello all!
As discussed in the previous post, we made a drastic change in the architecture of ruby_curry by utilising ICurry to cover the compilation steps while providing a robust runtime environment in ruby.
My mentor and I had discussions about how cumbersome the task of directly converting ICurry to Ruby was. The feature set was limited and needed extra programming just to obtain some information for the Ruby object code. As a suggestion to solve this, we decided to introduce a layer of abstraction over ICurry - called RCurry. RCurry will be a code level abstraction of the information in ICurry i.e. in order to convert ICurry into executable code we add an abstract layer which can then be converted to object code in any language.
This would make the generation of object highly language independent. All one has to do is create a runtime environment for execution and develop a pretty printer(or converter) for translating RCurry into language of their choice. This logical partition also makes maintenance and development easy.
On these lines, I have been working on defining RCurry and a module to convert ICurry to RCurry called ICurryToAbstractRuby. These modules are currently a stub under development and being tested on the try server. I plan on making it available on the Github repo by the end of next week, along with a couple of tasks implemented from the TODO list … So stay tuned :)


Gardai appeal for witnesses following death of man in Coolock shooting
by Nick FitzgeraldDue to critical injuries, the man was pronounced dead at Beaumont Hospital
Earlier, a man in his 20s was left in critical condition following a shooting in Coolock in north Dublin.
He has since passed away at Beaumont Hospital, due to "a number of apparent gunshot wounds."
The shooting took place on Clonshaugh Avenue in Dublin 17 at approximately 5:15pm on Sunday.
Gardai are appealing for witnesses to come forward with any relevant information.
A garda spokesperson said:
"Gardai are appealing for witnesses to come forward, they are also appealing to anyone with camera footage from the vicinity of Clonshaugh Avenue between 4.30pm and 5.30pm today to make it available to investigators.
"Anyone with information is asked to contact Coolock Garda Station 01-6664200 or the Garda Confidential Line 1800 666 111."
Detectives investigating the case believe the incident is linked to an ongoing feud in the Coolock area.
It is believed the victim was shot a total of six times in the upper body and arms and that two gunmen were involved in the attack.


Filters enable controllers to run shared pre and post processing code for its actions. These filters can be used to do authentication, caching, or auditing before the intended action is performed. Or to do localization or output compression after the action has been performed.
Filters have access to the request, response, and all the instance variables set by other filters in the chain or by the action (in the case of after filters). Additionally, it’s possible for a pre-processing before_filter to halt the processing before the intended action is processed by returning false or performing a redirect or render. This is especially useful for filters like authentication where you’re not interested in allowing the action to be performed if the proper credentials are not in order.
Filter inheritance
Controller inheritance hierarchies share filters downwards, but subclasses can also add new filters without affecting the superclass. For example:
class BankController < ActionController::Base before_filter :audit private def audit # record the action and parameters in an audit log end end class VaultController < BankController before_filter :verify_credentials private def verify_credentials # make sure the user is allowed into the vault end end
Now any actions performed on the BankController will have the audit method called before. On the VaultController, first the audit method is called, then the verify_credentials method. If the audit method returns false, then verify_credentials and the intended action are never called.
Filter types
A filter can take one of three forms: method reference (symbol), external class, or inline method (proc). The first is the most common and works by referencing a protected or private method somewhere in the inheritance hierarchy of the controller by use of a symbol. In the bank example above, both BankController and VaultController use this form.
Using an external class makes for more easily reused generic filters, such as output compression. External filter classes are implemented by having a static filter method on any class and then passing this class to the filter method. Example:
class OutputCompressionFilter def self.filter(controller) controller.response.body = compress(controller.response.body) end end class NewspaperController < ActionController::Base after_filter OutputCompressionFilter end
The filter method is passed the controller instance and is hence granted access to all aspects of the controller and can manipulate them as it sees fit.
The inline method (using a proc) can be used to quickly do something small that doesn’t require a lot of explanation. Or just as a quick test. It works like this:
class WeblogController < ActionController::Base before_filter { |controller| false if controller.params["stop_action"] } end
As you can see, the block expects to be passed the controller after it has assigned the request to the internal variables. This means that the block has access to both the request and response objects complete with convenience methods for params, session, template, and assigns. Note: The inline method doesn’t strictly have to be a block; any object that responds to call and returns 1 or -1 on arity will do (such as a Proc or an Method object).
Filter chain ordering
Using before_filter and after_filter appends the specified filters to the existing chain. That’s usually just fine, but some times you care more about the order in which the filters are executed. When that’s the case, you can use prepend_before_filter and prepend_after_filter. Filters added by these methods will be put at the beginning of their respective chain and executed before the rest. For example:
class ShoppingController before_filter :verify_open_shop class CheckoutController prepend_before_filter :ensure_items_in_cart, :ensure_items_in_stock
The filter chain for the CheckoutController is now :ensure_items_in_cart, :ensure_items_in_stock, :verify_open_shop. So if either of the ensure filters return false, we’ll never get around to see if the shop is open or not.
You may pass multiple filter arguments of each type as well as a filter block. If a block is given, it is treated as the last argument.
Around filters
In addition to the individual before and after filters, it’s also possible to specify that a single object should handle both the before and after call. That’s especially useful when you need to keep state active between the before and after, such as the example of a benchmark filter below:
class WeblogController < ActionController::Base around_filter BenchmarkingFilter.new # Before this action is performed, BenchmarkingFilter#before(controller) is executed def index end # After this action has been performed, BenchmarkingFilter#after(controller) is executed end class BenchmarkingFilter def initialize @runtime end def before start_timer end def after stop_timer report_result end end
Filter chain skipping
Some times its convenient to specify a filter chain in a superclass that’ll hold true for the majority of the subclasses, but not necessarily all of them. The subclasses that behave in exception can then specify which filters they would like to be relieved of. Examples
class ApplicationController < ActionController::Base before_filter :authenticate end class WeblogController < ApplicationController # will run the :authenticate filter end class SignupController < ApplicationController # will not run the :authenticate filter skip_before_filter :authenticate end
Filter conditions
Filters can be limited to run for only specific actions. This can be expressed either by listing the actions to exclude or the actions to include when executing the filter. Available conditions are +:only+ or +:except+, both of which accept an arbitrary number of method references. For example:
class Journal < ActionController::Base # only require authentication if the current action is edit or delete before_filter :authorize, :only => [ :edit, :delete ] private def authorize # redirect to login unless authenticated end end
When setting conditions on inline method (proc) filters the condition must come first and be placed in parentheses.
class UserPreferences < ActionController::Base before_filter(:except => :new) { # some proc ... } # ... end
- after_filter
- append_after_filter
- append_around_filter
- append_before_filter
- around_filter
- before_filter
- prepend_after_filter
- prepend_around_filter
- prepend_before_filter
- skip_after_filter
- skip_before_filter
Alias for append_after_filter
The passed filters will be appended to the array of filters that’s run after actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 195 195: def append_after_filter(*filters, &block) 196: conditions = extract_conditions!(filters) 197: filters << block if block_given? 198: add_action_conditions(filters, conditions) 199: append_filter_to_chain('after', filters) 200: end
The passed filters will have their before method appended to the array of filters that’s run both before actions on this controller are performed and have their after method prepended to the after actions. The filter objects must all respond to both before and after. So if you do append_around_filter A.new, B.new, the callstack will look like:
B#before A#before A#after B#after
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 222 222: def append_around_filter(*filters) 223: conditions = extract_conditions!(filters) 224: for filter in filters.flatten 225: ensure_filter_responds_to_before_and_after(filter) 226: append_before_filter(conditions || {}) { |c| filter.before(c) } 227: prepend_after_filter(conditions || {}) { |c| filter.after(c) } 228: end 229: end
The passed filters will be appended to the array of filters that’s run before actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 174 174: def append_before_filter(*filters, &block) 175: conditions = extract_conditions!(filters) 176: filters << block if block_given? 177: add_action_conditions(filters, conditions) 178: append_filter_to_chain('before', filters) 179: end
Alias for append_around_filter
Alias for append_before_filter
The passed filters will be prepended to the array of filters that’s run after actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 204 204: def prepend_after_filter(*filters, &block) 205: conditions = extract_conditions!(filters) 206: filters << block if block_given? 207: add_action_conditions(filters, conditions) 208: prepend_filter_to_chain("after", filters) 209: end
The passed filters will have their before method prepended to the array of filters that’s run both before actions on this controller are performed and have their after method appended to the after actions. The filter objects must all respond to both before and after. So if you do prepend_around_filter A.new, B.new, the callstack will look like:
A#before B#before B#after A#after
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 239 239: def prepend_around_filter(*filters) 240: for filter in filters.flatten 241: ensure_filter_responds_to_before_and_after(filter) 242: prepend_before_filter { |c| filter.before(c) } 243: append_after_filter { |c| filter.after(c) } 244: end 245: end
The passed filters will be prepended to the array of filters that’s run before actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 183 183: def prepend_before_filter(*filters, &block) 184: conditions = extract_conditions!(filters) 185: filters << block if block_given? 186: add_action_conditions(filters, conditions) 187: prepend_filter_to_chain('before', filters) 188: end
Removes the specified filters from the after filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 274 274: def skip_after_filter(*filters) 275: if conditions = extract_conditions!(filters) 276: remove_contradicting_conditions!(filters, conditions) 277: conditions[:only], conditions[:except] = conditions[:except], conditions[:only] 278: add_action_conditions(filters, conditions) 279: else 280: for filter in filters.flatten 281: write_inheritable_attribute("after_filters", read_inheritable_attribute("after_filters") - [ filter ]) 282: end 283: end 284: end
Removes the specified filters from the before filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 256 256: def skip_before_filter(*filters) 257: if conditions = extract_conditions!(filters) 258: remove_contradicting_conditions!(filters, conditions) 259: conditions[:only], conditions[:except] = conditions[:except], conditions[:only] 260: add_action_conditions(filters, conditions) 261: else 262: for filter in filters.flatten 263: write_inheritable_attribute("before_filters", read_inheritable_attribute("before_filters") - [ filter ]) 264: end 265: end 266: end


|
|||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Defining a generic selecting or updating query that can be executed in Cayenne.
QueryEngine
| Field Summary | |
static org.apache.log4j.Level |
DEFAULT_LOG_LEVEL
|
static int |
DELETE_QUERY
Deprecated. Since 1.1 Query type is no longer relevant. |
static int |
INSERT_QUERY
Deprecated. Since 1.1 Query type is no longer relevant. |
static int |
SELECT_QUERY
Deprecated. Since 1.1 Query type is no longer relevant. |
static int |
UNKNOWN_QUERY
Deprecated. Since 1.1 Query type is no longer relevant. |
static int |
UPDATE_QUERY
Deprecated. Since 1.1 Query type is no longer relevant. |
| Method Summary | |
org.apache.log4j.Level |
getLoggingLevel()
Returns the logLevel property of this query. |
java.lang.String |
getName()
Returns a symbolic name of the query. |
int |
getQueryType()
Deprecated. Since 1.1 Query type is no longer relevant. |
java.lang.Object |
getRoot()
Returns the root object of this query. |
void |
setLoggingLevel(org.apache.log4j.Level level)
|
void |
setName(java.lang.String name)
Sets a symbolic name of the query. |
void |
setRoot(java.lang.Object value)
Sets the root of the query. |
| Field Detail |
public static final org.apache.log4j.Level DEFAULT_LOG_LEVEL
public static final int SELECT_QUERY
public static final int INSERT_QUERY
public static final int UPDATE_QUERY
public static final int DELETE_QUERY
public static final int UNKNOWN_QUERY
| Method Detail |
public java.lang.String getName()
public void setName(java.lang.String name)
public org.apache.log4j.Level getLoggingLevel()
logLevel
property of this query. Log level is a hint to
QueryEngine that performs this query to log execution with a certain priority.
public void setLoggingLevel(org.apache.log4j.Level level)
public int getQueryType()
public java.lang.Object getRoot()
public void setRoot(java.lang.Object value)
value
- The new root
|
|||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{% extends 'layout/default.html' %} {% load i18n cms_tags markdown_deux_tags staticfiles pipeline bootstrap3 %} {% block title %}Sharing Portal | Chameleon Cloud {% endblock %} {% block styles %} {{ block.super }} {% endblock %} {% block content %} {# Experiments / [current_exp_title] subheader #}
Launching this artifact will open it within Chameleon’s shared Jupyter experiment environment, which is accessible to all Chameleon users with an active allocation.


{% extends "base.html" %} {% block container %}
Disclaimer: The service ( lyfjabókin.is ) that gives us details/info for each individual drug currently lies dow at the momment of writing this message, but hopefully it will be back up at the time when this project is reviewed
{% endblock %}


Welcome to Urlinq, Jacob
To start exploring a campus and its people, select your school below
Next
Search
Polytechnic School of Engineering
College of Arts and Sciences
Stern School of Business
Tisch School of the Arts
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study
Gallatin School of Individualized Study


For best results, you should synchronize the clocks used by all machines in a replication group. If you are using a time-based consistency policy, this is an absolute requirement (see Time Consistency Policies for more information). Time synchronization is easily achieved using a mechanism like NTPD.
In addition, time synchronization is also a requirement for
internal JE HA bookkeeping. For example, JE checks for clock
skew between the Master and a Replica
when the Replica performs its startup handshake with the
Master. This handshake will abort and throw
EnvironmentFailureException if the clock skew between the
two machines is greater than the value set for the
MAX_CLOCK_DELTA property. This property can be set using the
ReplicationConfig.setMaxClockDelta() method, or in the JE
configuration file using the
je.rep.maxClockDelta
property.
Finally, well synchronized clocks make it easier to correlate events in the logging output from different nodes in the group.


--- layout: master title: Introduction ---
Speed up development, we have done all the boilerplate work for you.
Use it for your project documentation, personal website or blog.
Built with love and open source for all to benefit.
Due to Jekyll also using handlebars, we have overriden the Angular template markup to use {[{ '\{\[\{ bracers \}\]\}' }]}
Date conversion: {[{<PHONE_NUMBER>00 | date:'medium' }]}
Repeat: {[{ i }]}


Yemeni rebels seized Saudi tug, South Korean rig, Red sea
by Mikhail VoytenkoSaudi’s tug RABIGH 3 was attacked and boarded by Houthi militia at 1850 UTC Nov 17 in Red sea in position 15 25N 042 18E, N of Kamaran Island, Yemen. Tug was seized and taken to Al Qaryah, Yemeni waters, off Kamaran island. A number of sources said tug was towing South Korean drilling rig, which was also seized. Houthi leaders said the rig will be released. Tug’s AIS is on, but rig can’t be identified.
Tug RABIGH 3, IMO 8600105, GT 545, built 1987, flag Saudi Arabia, manager MARINE SERVICES CO LTD-SAU.


Mini abandoned in flooded Derbyshire road attacked by vandals
Its windows have been smashed
by Nick ReidA Mini left abandoned in a flooded Derbyshire road has had its windows smashed and sides damaged.
The car was left abandoned on a country lane between Swarkestone Bridge and Ingleby, earlier this week.
An earlier picture showed how water had risen up onto its wheels, just underneath the numberplate.
New dashcam footage shows how the car has now been damaged on the front and side panel.
The driver window has also been broken since it was left in the road. The back light has also been damaged.
Flooding has led to several road closures and train cancellations across the county.
Flood warnings, meaning flooding is expected and immediate action is required, are in place on the River Trent at Sawley, the River Derwent at Church Wilne and the River Erewash at Langley Mill and Ilkeston.
Several replacement bus services have been put in place in between Derby and Nottingham throughout the day in a bid to keep commuters on the move.
Flooding continues to cause problems and we have a live blog running as the events of the day unfold.
You can follow it here.


{% extends "layout.html" %} {% block title %}Successfully registered{% endblock %} {% block content %}
Sorry, {{ user }}, we were unable to register you. Please contact geofft for help.


Running generic stories via a web-based interface
The Web Runner provides a simple web-based interface to running
generic stories. A typical use case is for BAs, QAs or stakeholders to
be able to access the results of story running without needing access to
developer resources, e.g. source control or build systems.
A fully functional example webapp is provided in trader
runner example. We'll be using this example to illustrate the use of Web
Runner:
- Customise Web Runner
- Deploy webapp to your favourite webapp container
- Open page http://localhost:8080/trader-runner (assuming
normal port conventions)
Run Story
The Run Story page allows the user to run any textual story and
to display the result in the same page.
- From Menu, click on Run Story, which will take you to a
page where you can enter your textual story.
- Input textual story in textarea (e.g you can cut & paste
the sample scenarios found in the trader
story) and click on Run button.
- Optionally, a meta filter can be specified. This requires the Web Runner to
be built using JBehave Core 3.1+.
- Upon execution, the output of the story is shown below. By
default the same output is shown as the one you would see when running
JBehave via a command-line interface. This includes any details of
failed and pending steps. If any failures occur, the user has the stack
trace in an expandable section below.
Find Steps
The Find Steps page allows the user to find steps (i.e. methods
in steps instances classes) and to display the patterns and the
associated methods.
- From Menu, click on Find Steps, which will take you to
a page where you can enter your textual step.
- Input textual step in textarea (e.g you can cut & paste a
step from the sample scenarios found in the trader
story) and click on Find button.
- A blank input will simply show all the steps that are
configured.
- Upon execution, the steps found are shown below. By default,
only the patterns are shown, but you can choose to also display
associated methods.
- The final section shows the steps instances that were
configured and were used to find steps.
Data Files
The Data Files page allows the user to upload and view any data
file that may be used during the execution of the story. Data files can
be either single text files or zip archives. If archives, these are
automatically unzipped when upload to the server.
- From Menu, click on Data Files, which will take you to
a page where you can view the files already uploaded to the upload
directory (defaults to "/tmp/upload" but is configurable via the WebRunnerApplication#uploadDirectory()).
- Use the Browse and Upload buttons to upload any
file to the upload directory.
- Use the Show Content and Hide Content buttons to
toggle display of uploaded file content.
- Click on View link next to the files to view their
content.
- Use the Delete button to delete any selected files.


dtuf module¶
dtuf.DTufBase (host[, auth, insecure, auth_host]) |
Class for communicating with a Docker v2 registry. |
dtuf.DTufMaster (host, repo[, repos_root, …]) |
Class for creating, updating and publishing data to repositories in a Docker registry using The Update Framework (TUF). |
dtuf.DTufCopy (host, repo[, repos_root, …]) |
Class for downloading data from repositories in a Docker registry using The Update Framework (TUF). |
Docker registry bindings for The Update Framework
-
class
dtuf.
DTufBase
(host, auth=None, insecure=False, auth_host=None)¶ Bases:
object
Class for communicating with a Docker v2 registry. Contains only operations which aren’t related to pushing and pulling data to repositories in the registry using The Update Framework.
Can act as a context manager. For each context entered, a new requests.Session is obtained. Connections to the same host are shared by the session. When the context exits, all the session’s connections are closed.
If you don’t use
DTufBase
as a context manager, each request uses an ephemeral session. If you don’t read all the data from an iterator returned byDTufCopy.pull_target()
then the underlying connection won’t be closed until Python garbage collects the iterator.Parameters: - host (str) – Host name of registry. Can contain port numbers. e.g.
registry-1.docker.io
,localhost:5000
. - auth (function(dtuf_obj, response)) – Authentication function to be called whenever authentication to the registry is required. Receives the
DTufBase
object and a HTTP response object. It should callauthenticate()
ondtuf_obj
with a username, password andresponse
before it returns. - insecure (bool) – Use HTTP instead of HTTPS (which is the default) when connecting to the registry.
- auth_host (str) – Host to use for token authentication. If set, overrides host returned by then registry.
-
authenticate
(username=None, password=None, actions=None, response=None)¶ Authenticate to the registry, using a username and password if supplied, otherwise as the anonymous user.
Parameters: - username (str) – User name to authenticate as.
- password (str) – User’s password.
- actions (list) – If you know which types of operation you need to make on the registry, specify them here. Valid actions are
pull
,push
and*
. - response (requests.Response) – When the
auth
function you passed toDTufBase
’s constructor is called, it is passed a HTTP response object. Pass it back toauthenticate()
to have it automatically detect which actions are required.
Return type: str
Returns: Authentication token, if the registry supports bearer tokens. Otherwise
None
, and HTTP Basic auth is used.
-
list_repos
()¶ List all repositories in the registry.
Return type: list Returns: List of repository names.
-
token
¶ str: Authentication token. This will be obtained automatically when you call
authenticate()
. If you’ve obtained a token previously, you can also set it but be aware tokens expire quickly.
- host (str) – Host name of registry. Can contain port numbers. e.g.
-
class
dtuf.
DTufCopy
(host, repo, repos_root=None, auth=None, insecure=False, auth_host=None)¶ Bases:
dtuf._DTufCommon
Class for downloading data from repositories in a Docker registry using The Update Framework (TUF).
Parameters: - host (str) – Host name of registry. Can contain port numbers. e.g.
registry-1.docker.io
,localhost:5000
. - repo (str) – Name of the repository to access on the registry. Typically this is of the form
username/reponame
but for your own registries you don’t actually have to stick to that. The repository is used to retrieve data and TUF metadata describing the data. - repos_root (str) – Directory under which to store TUF metadata. Note that the value of
repo
and the literal stringcopy
are appended to this directory name before storing the metadata. Defaults todtuf_repos
in the current working directory. - auth (function(dtuf_obj, response)) – Authentication function to be called whenever authentication to the registry is required. Receives the
DTufBase
object and a HTTP response object. It should callDTufBase.authenticate()
with a username, password andresponse
before it returns. - insecure (bool) – Use HTTP instead of HTTPS (which is the default) when connecting to the registry.
- auth_host (str) – Host to use for token authentication. If set, overrides host returned by then registry.
-
blob_sizes
(target)¶ Return the sizes of all the blobs which make up a target.
Parameters: target (str) – Name of target Returns: List of blob sizes Return type: list
-
check_target
(target, *filenames)¶ Check whether the hashes of a target’s blobs match the hashes of a given list of filenames.
Raises dxf.exceptions.DXFDigestMismatchError if they don’t.
Parameters: - target (str) – Name of target to check.
- filenames (list) – Names of files to check against.
-
get_expirations
()¶ Return the expiration dates of the local TUF metadata copy.
Returns: A dictionary containing datetime values for the keys root
,targets
,snapshot
andtimestamp
.Return type: dict
-
list_targets
()¶ Return the names of all the targets defined in the local copy of the TUF metadata.
Returns: List of target names Return type: list
-
pull_metadata
(root_public_key=None, progress=None)¶ Download TUF metadata from the repository.
The metadata is checked for expiry and verified against the root public key for the repository.
You only need to supply the root public key once, and you should obtain it from the person who uploaded the metadata.
Target data is not downloaded - use
pull_target()
for that.Parameters: - root_public_key (str) – PEM-encoded root public key. Obtain this from the repository’s owner, who generates the key using
DTufMaster.create_root_key()
on the repository master. - progress (function(dgst, chunk, total)) – Optional function to call as the download progresses. The function will be called with the hash of the metadata currently being download, the blob just read from the repository and the total size of the metadata.
Returns: List of targets which have been updated since you last downloaded them (using
pull_target()
).Return type: list
- root_public_key (str) – PEM-encoded root public key. Obtain this from the repository’s owner, who generates the key using
-
pull_target
(target, digests_and_sizes=False)¶ Download a target (data) from the repository.
Target data consists of one or more separate blobs (depending on how many were uploaded). Because this function returns an iterator, download of each blob occurs lazily.
Target information is stored in the TUF metadata, so you should have called
pull_metadata()
previously.Parameters: - target (str) – Name of the target to download.
- digests_and_sizes (bool) – Whether to return the hash and size of each downloaded blob as well.
Returns: If
digests_and_sizes
is falsey, an iterator which yields for each blob an iterator over its content. Ifdigests_and_sizes
is truthy, an iterator which yields for each blob a tuple containing an iterator over its content, the hash of its content and its size.Return type: iterator
- host (str) – Host name of registry. Can contain port numbers. e.g.
-
class
dtuf.
DTufMaster
(host, repo, repos_root=None, auth=None, insecure=False, auth_host=None, root_lifetime=None, targets_lifetime=None, snapshot_lifetime=None, timestamp_lifetime=None)¶ Bases:
dtuf._DTufCommon
Class for creating, updating and publishing data to repositories in a Docker registry using The Update Framework (TUF).
Parameters: - host (str) – Host name of registry. Can contain port numbers. e.g.
registry-1.docker.io
,localhost:5000
. - repo (str) – Name of the repository to access on the registry. Typically this is of the form
username/reponame
but for your own registries you don’t actually have to stick to that. The repository is used to store data and TUF metadata describing the data. - repos_root (str) – Directory under which to store TUF metadata. Note that the value of
repo
and the literal stringmaster
are appended to this directory name before storing the metadata. Defaults todtuf_repos
in the current working directory. - auth (function(dtuf_obj, response)) – Authentication function to be called whenever authentication to the registry is required. Receives the
DTufBase
object and a HTTP response object. It should callDTufBase.authenticate()
ondtuf_obj
with a username, password andresponse
before it returns. - insecure (bool) – Use HTTP instead of HTTPS (which is the default) when connecting to the registry.
- auth_host (str) – Host to use for token authentication. If set, overrides host returned by then registry.
- root_lifetime (datetime.timedelta) – Lifetime of the TUF root metadata. After this time expires, you’ll need to call
reset_keys()
andpush_metadata()
to re-sign the metadata. Defaults totuf.repository_tool.ROOT_EXPIRATION
(1 year). - targets_lifetime (datetime.timedelta) – Lifetime of the TUF targets metadata. After this time expires, you’ll need to call
push_metadata()
to re-sign the metadata. Defaults totuf.repository_tool.TARGETS_EXPIRATION
(3 months). - snapshot_lifetime (datetime.timedelta) – Lifetime of the TUF snapshot metadata. After this time expires, you’ll need to call
push_metadata()
to re-sign the metadata. Defaults totuf.repository_tool.SNAPSHOT_EXPIRATION
(1 week). - timestamp_lifetime (datetime.timedelta) – Lifetime of the TUF timestamp metadata. After this time expires, you’ll need to call
push_metadata()
to re-sign the metadata. Defaults totuf.repository_tool.TIMESTAMP_EXPIRATION
(1 day).
-
create_metadata
(root_key_password=None, targets_key_password=None, snapshot_key_password=None, timestamp_key_password=None)¶ Create and sign the TUF metadata for the repository.
You only need to call this once for each repository, and the repository’s root and metadata private keys must be available.
Parameters: - root_key_password – Password to use for decrypting the TUF root private key. You’ll be prompted for one if you don’t supply it.
- targets_key_password – Password to use for decrypting the TUF targets private key. You’ll be prompted for one if you don’t supply it.
- snapshot_key_password – Password to use for decrypting the TUF snapshot private key. You’ll be prompted for one if you don’t supply it.
- timestamp_key_password – Password to use for decrypting the TUF timestamp private key. You’ll be prompted for one if you don’t supply it.
-
create_metadata_keys
(targets_key_password=None, snapshot_key_password=None, timestamp_key_password=None)¶ Create TUF metadata keypairs for the repository.
The keys are written to the
<repos_root>/<repo>/master/keys
directory. The public keys have a.pub
extension.You can move the private keys offline once you’ve called
create_metadata()
but you’ll need them again when you callpush_metadata()
to publish the repository.You don’t need to give out the metadata public keys since they’re published on the repository.
Parameters: - targets_key_password – Password to use for encrypting the TUF targets private key. You’ll be prompted for one if you don’t supply it.
- snapshot_key_password – Password to use for encrypting the TUF snapshot private key. You’ll be prompted for one if you don’t supply it.
- timestamp_key_password – Password to use for encrypting the TUF timestamp private key. You’ll be prompted for one if you don’t supply it.
-
create_root_key
(password=None)¶ Create root keypair for the repository.
The private key is written to
<repos_root>/<repo>/master/keys/root_key
and can be moved offline once you’ve calledcreate_metadata()
. You’ll need it again if you callreset_keys()
when the root metadata expires.The public key is written to
<repos_root>/<repo>/master/keys/root_key.pub
and can be given to others for use when retrieving a copy of the repository metadata withDTufCopy.pull_metadata()
.Parameters: password (str) – Password to use for encrypting the private key. You’ll be prompted for one if you don’t supply it.
-
del_target
(target)¶ Delete a target (data) from the repository and update the local TUF metadata.
The metadata isn’t updated on the registry until you call
push_metadata()
.Note that the registry doesn’t support deletes yet so expect an error.
Parameters: target (str) – The name you gave to the data when it was uploaded using push_target()
.
-
get_expirations
()¶ Return the expiration dates of the TUF metadata.
Returns: A dictionary containing datetime values for the keys root
,targets
,snapshot
andtimestamp
.Return type: dict
-
list_targets
()¶ Return the names of all the targets defined in the local TUF metadata.
Returns: List of target names Return type: list
-
push_metadata
(targets_key_password=None, snapshot_key_password=None, timestamp_key_password=None, progress=None)¶ Upload local TUF metadata to the repository.
The TUF metadata consists of a list of targets (which were uploaded by
push_target()
), a snapshot of the state of the metadata (list of hashes), a timestamp and a list of public keys.This function signs the metadata except for the list of public keys, so you’ll need to supply the password to the respective private keys.
The list of public keys was signed (along with the rest of the metadata) with the root private key when you called
create_metadata()
(orreset_keys()
).Parameters: - targets_key_password – Password to use for decrypting the TUF targets private key. You’ll be prompted for one if you don’t supply it.
- snapshot_key_password – Password to use for decrypting the TUF snapshot private key. You’ll be prompted for one if you don’t supply it.
- timestamp_key_password – Password to use for decrypting the TUF timestamp private key. You’ll be prompted for one if you don’t supply it.
- progress (function(dgst, chunk, total)) – Optional function to call as the upload progresses. The function will be called with the hash of the content of the file currently being uploaded, the blob just read from the file and the total size of the file.
-
push_target
(target, *filename_or_target_list, **kwargs)¶ Upload data to the repository and update the local TUF metadata.
The metadata isn’t uploaded until you call
push_metadata()
.The data is given a name (known as the
target
) and can come from a list of files or existing target names.Parameters: - target (str) – Name to give the data.
- filename_or_target_list (list) – List of data to upload. Each item is either a filename or an existing target name. Existing target names should be prepended with
@
in order to distinguish them from filenames. - kwargs (dict({'progress': function(dgst, chunk, total)})) – Contains an optional
progress
member which is a function to call as the upload progresses. The function will be called with the hash of the content of the file currently being uploaded, the blob just read from the file and the total size of the file.
-
reset_keys
(root_key_password=None, targets_key_password=None, snapshot_key_password=None, timestamp_key_password=None)¶ Re-sign the TUF metadata for the repository.
Call this if you’ve generated new root or metadata keys (because one of the keys has been compromised, for example) but you don’t want to delete the repository and start again.
Parameters: - root_key_password – Password to use for decrypting the TUF root private key. You’ll be prompted for one if you don’t supply it.
- targets_key_password – Password to use for decrypting the TUF targets private key. You’ll be prompted for one if you don’t supply it.
- snapshot_key_password – Password to use for decrypting the TUF snapshot private key. You’ll be prompted for one if you don’t supply it.
- timestamp_key_password – Password to use for decrypting the TUF timestamp private key. You’ll be prompted for one if you don’t supply it.
- host (str) – Host name of registry. Can contain port numbers. e.g.
dtuf.exceptions module¶
Module containing exceptions thrown by dtuf
.
-
exception
dtuf.exceptions.
DTufError
¶ Bases:
exceptions.Exception
Base exception class for all dtuf errors
-
exception
dtuf.exceptions.
DTufReservedTargetError
(target)¶ Bases:
dtuf.exceptions.DTufError
Target name is reserved so can’t be used in
dtuf.DTufMaster.push_target()
.Parameters: target (str) – Target name


"We are delighted Pique wants to go to the Olympic Games with Spain"
Coach Luis de la Fuente spoke about the possibility of calling him up for the Games
by sport.esSpain U21 coach Luis de la Fuente, who will be in charge of La Roja's U23 side at the Olympic Games, says it's good news many big players want to be involved in Tokyo.
First Sergio Ramos said he would like to play for Spain at the Games and then Gerard Pique suggested he would be open to the option if called up.
"I say the same as I said with Sergio Ramos," de la Fuente said about Pique. "We are happy that they want to come, but we will see what decisions are made.
"The players that come will be the ones that we want in function to their performance and we are open to these possibilities."
Meanwhile, Spain coach Robert Moreno indicated that he's not hoping to have Pique back for Euro 2020.
"Pique is a great player, but he has already retired from the national team so we're not planning to have him back," Moreno said in a news conference on Friday.
Barcelona defender Pique called time on his international career after Spain's World Cup campaign in Russia last summer.


What is a Mapper?
In functional programming, maps are used to apply a function to each element in a list and return the result list. For example, if you apply the function f(x) = x . x to the list [1, 2, 3], then you get the result list [1,4,9]. We will call a class that does this job in Java an Array or Collection Mapper.
In more general terms, functions in the mathematical sense are mappers because they map from one space (input space or domain) to another (output space or domain). For more on the subject, see Higher Order Functions on Wiki.
Arrays =~ Lists In Java
In Java, arrays have list semantics, but they are not ‘List’s. They do not implement the List interface for example. Here, I present a mapper that will apply a function to all elements in an array, and return the array result.
Why Map Arrays?
It makes for a better code in terms of readability. It makes for a far more concise and terse coding structures. It also allows you to think more abstractly about what you are trying to apply on each element (without thinking about the loops), then at will decide to apply that to lists, arrays, sets, or whatever.
So, first, here is the mapper that does the deed. The class takes the output class and a single item mapper:
package uk.co.codebreeze.arraymapper;
import java.lang.reflect.Array;
public class ArrayMapper<I,O> implements Mapper<I[], O[]> {
private final Mapper<I, O> itemMapper;
private final Class oClass;
public ArrayMapper(final Mapper<I,O> itemMapper, final Class oClass){
this.itemMapper = itemMapper;
this.oClass = oClass;
}
public O[] map(final I[] input) {
O[] output = (O[]) Array.newInstance(oClass, input.length);
for(int i = 0; i < input.length; i++){
output[i] = itemMapper.map(input[i]);
}
return output;
}
}
The following code is a supporting interface. The Mapper
implemented by both the single item mapper provided to the array mapper constructor above, and the generic array mapper itself:
package uk.co.codebreeze.arraymapper;
public interface Mapper<I,O> {
O map(I i);
}
Here is also a test to show how you may use the mapper, and prove it works as expected. Note how the separation of concerns works. We defined the string to integer conversion/mapping as a separate code, then, we could apply it to an array.
package uk.co.codebreeze.arraymapper;
import static org.junit.Assert.*;
import java.lang.reflect.Array;
import org.junit.Test;
public class ArrayMapperTest {
@Test
public void testMap() {
//given
final Mapper<String, Integer> string2Integer = new Mapper<String, Integer>() {
public Integer map(String i) {
return Integer.valueOf(i);
}
};
final String[] strings = new String[]{"1", "2", "4", "66"};
//when
final Mapper<String[], Integer[]> am = new ArrayMapper<String, Integer>(string2Integer, Integer.class);
//then
final Integer[] result = am.map(strings);
assertArrayEquals(new Integer[]{1, 2, 4, 66}, result);
assertFalse(Array.newInstance(Integer.class, 0).equals(Array.newInstance(Integer.class, 0)));
assertFalse(Array.newInstance(Integer.class, 1).equals(Array.newInstance(Integer.class, 1)));
}
}
As always, constructive feedback is always welcome.