What is Microsoft Computer Vision API?
Computer Vision API helps to recognize the thing in the picture. As you can see from the above image, Computer Vision API used application detected the person in the picture. And it is detecting whther this picture is an Adult Content or not. Let's get started to use this mysterious API!
Link to Microsoft Computer Vision API
This is URL which lets redirect you to Microsoft Computer Vision API.
https://azure.microsoft.com/en-us/services/cognitive-services/computer-vision/Getting a key to use the API
What you need to do first to use Microsoft Computer vision API is to get a key like other API. Where can we get the key by the way. First go to the website and click “FREE ACCOUNT”.
TIP!!
There is a documentation explaining about Obtaining Subscription Keys from Documentation category from the website. Based on my experiment, it does not work well only making 401 error. There also suggests a way to get a key using Microsoft Azure. So it is better to get a key from that route.(The bad thing is it gives only 30 days free trial, but it is enough to test and experience what Computer Vision API is.)
Now you should make a free account. Making an account is free as it says.
You can see that page. As it says you can start free at first but it is free only for 30 days. Anyway, let’s get it started. Click “Start free” button. It is easy to make an account so I will skip that part here. As you make an account, and log in you can see this page. Click “Portal” button.
You get to the portal. There are various sub directories on the left side of the page. Click “New” button.
Look for Computer Vision API. And Click Computer Vision API.
Click "Create".
Type and select everything required to create Computer vision API on your Dashboard. And click “Create”.
Now you will see this page, and you can click “Show access keys…” link.
And finally you can click that button to copy the key, which you can use to use Microsoft Computer Vision API. Congratulations!


- B
- C
- D
- H
- I
- J
- L
- M
- N
- P
- T
- U
- X
Source: show
# File<EMAIL_ADDRESS>line 79 def bit(name, options = {}) column(name, :bit, options) end
Source: show
# File<EMAIL_ADDRESS>line 83 def bit_varying(name, options = {}) column(name, :bit_varying, options) end
Source: show
# File<EMAIL_ADDRESS>line 51 def cidr(name, options = {}) column(name, :cidr, options) end
Source: show
# File<EMAIL_ADDRESS>line 71 def citext(name, options = {}) column(name, :citext, options) end
Source: show
# File<EMAIL_ADDRESS>line 35 def daterange(name, options = {}) column(name, :daterange, options) end
Source: show
# File<EMAIL_ADDRESS>line 39 def hstore(name, options = {}) column(name, :hstore, options) end
Source: show
# File<EMAIL_ADDRESS>line 47 def inet(name, options = {}) column(name, :inet, options) end
Source: show
# File<EMAIL_ADDRESS>line 15 def int4range(name, options = {}) column(name, :int4range, options) end
Source: show
# File<EMAIL_ADDRESS>line 19 def int8range(name, options = {}) column(name, :int8range, options) end
Source: show
# File<EMAIL_ADDRESS>line 63 def json(name, options = {}) column(name, :json, options) end
Source: show
# File<EMAIL_ADDRESS>line 67 def jsonb(name, options = {}) column(name, :jsonb, options) end
Source: show
# File<EMAIL_ADDRESS>line 43 def ltree(name, options = {}) column(name, :ltree, options) end
Source: show
# File<EMAIL_ADDRESS>line 55 def macaddr(name, options = {}) column(name, :macaddr, options) end
Source: show
# File<EMAIL_ADDRESS>line 87 def money(name, options = {}) column(name, :money, options) end
Source: show
# File<EMAIL_ADDRESS>line 31 def numrange(name, options = {}) column(name, :numrange, options) end
Source: show
# File<EMAIL_ADDRESS>line 75 def point(name, options = {}) column(name, :point, options) end
Source: show
# File<EMAIL_ADDRESS>line 23 def tsrange(name, options = {}) column(name, :tsrange, options) end
Source: show
# File<EMAIL_ADDRESS>line 27 def tstzrange(name, options = {}) column(name, :tstzrange, options) end
Source: show
# File<EMAIL_ADDRESS>line 10 def tsvector(*args) options = args.extract_options! column(args[0], :tsvector, options) end


| HOST (ARCH) | CONTAINERS | ITEMS | STATUS |
|---|
Rows per page
10
Card title
Secondary text
Greyhound divisively hello coldly wonderfully marginally far upon excluding.


Despite being around for a very long time, Lyme disease and ticks have only recently become a top-of-mind health issue. That’s because the areas of Ontario considered ‘at-risk’ for Lyme disease are growing every year, thanks at least in part to climate change. In fact, southern Wellington County is now an ‘at-risk’ area. But, because ticks can be transported around by animals (including birds), you could encounter one almost anywhere in the province.
1.Ticks are usually found in wooded or brushy areas.2. Ticks do not fly, jump or move quickly.3. The most common tick in Wellington, Dufferin and Guelph is the American Dog Tick. It is not associated with Lyme disease.4. The blacklegged tick population is expanding in the area and may transmit the bacteria that causes Lyme disease.5. Quick detection and removal through daily tick checks is unlikely to result in Lyme disease transmission.6. A tick that is feeding will get swollen and oversized over time.7. In Ontario, blacklegged ticks are more commonly found on the north shores of Lake Ontario and Lake Erie.


Squad provides a fresh, social saving experience helping you save for the stuff that matters with the people who matter.
Overcoming challenges and staying motivated is easier in a group. Just like how you train harder and more frequently at the gym with your mates, saving is easier as a Squad.


Loading...
At Pecan advisors our strength lies in supporting the real estate developers in the process of Fund Raising and Joint Ventures.
Our understanding of the Real Estate business, Market Conditions, Financial Analysis and deal structuring capabilities put us in a strong position to comprehend and work in closely with the promoters.
An Advisory firm with experience across industries in corporate finance , Fund Raising, Mergers and Acquisition. Pecan Advisors thrives on deep understanding of real estate and strong business relationships with NBFCs and Private Equity firms.


Arsenal POISED to swoop for Real Madrid ace in January to bolster attack
by Ron CarneReal Madrid boss Zinedine Zidane reportedly has no space for Vinicius Jr in his plans and Arsenal could be in line to benefit with a January swoop touted.
The 19-year-old Brazilian starlet joined Los Blancos from Flamengo last year and made a decent first impression with seven goals and 13 assists in 36 appearances across senior and youth level.
SEE MORE: Unai Emery hints at when Granit Xhaka could make return for Arsenal
However, he has struggled to follow that up this campaign so far, as he has just one goal and one assist in 11 outings, and so that has seemingly led to question marks being raised over his future at the Bernabeu as he has also at times been left out of the match day squad entirely.
According to Calciomercato, it’s suggested that Vinicius doesn’t form part of Zidane’s plans moving forward and in turn is being touted to leave in January.
Further, it’s noted that Arsenal could look to advantage of the situation and swoop and so it remains to be seen whether an agreement is reached between the two clubs.
It would arguably be a surprise move from the Spanish giants to give up on Vinicius so soon after signing him though, as he is still only 19 and has time and the talent to significantly improve his game it would seem.
On the other hand, with the likes of Eden Hazard, Rodrygo, Marco Asensio, Brahim Diaz, Lucas Vazquez, Gareth Bale and others all vying for places in the final third, there is serious competition for places and so perhaps Real Madrid need to trim the numbers and Vinicius would certainly be capable of giving them a decent return in terms of a transfer fee.


Register
Choose your primary game
-- select an option --
Counter-Strike
Dota 2
PES 2020
Call of Duty
Sign Up


CSPICE_OCCULT determines the occultation condition (not occulted,
partially, etc.) of one target relative to another target as seen
by an observer at a given time.
The surfaces of the target bodies may be represented by triaxial
ellipsoids or by topographic data provided by DSK files.
Given:
target1 is the name of the first target body. Both object
names and NAIF IDs are accepted. For example, both
'Moon' and '301' are accepted.
[1,a] = size(target1), char = class(target1)
shape1 is a string indicating the geometric model used to
represent the shape of the first target body.
[1,b] = size(shape1), char = class(shape1)
The supported options are:
'ELLIPSOID'
Use a triaxial ellipsoid model with radius values
provided via the kernel pool. A kernel variable
having a name of the form
'BODYnnn_RADII'
where nnn represents the NAIF integer code
associated with the body, must be present in the
kernel pool. This variable must be associated with
three numeric values giving the lengths of the
ellipsoid's X, Y, and Z semi-axes.
'POINT'
Treat the body as a single point. When a point
target is specified, the occultation conditions
can only be total, annular, or none.
'DSK/UNPRIORITIZED[/SURFACES = <surface list>]'
Use topographic data provided by DSK files to
model the body's shape. These data must be
provided by loaded DSK files.
The surface list specification is optional. The
syntax of the list is
<surface 1> [, <surface 2>...]
If present, it indicates that data only for the
listed surfaces are to be used; however, data
need not be available for all surfaces in the
list. If absent, loaded DSK data for any surface
associated with the target body are used.
The surface list may contain surface names or
surface ID codes. Names containing blanks must
be delimited by double quotes, for example
SURFACES = "Mars MEGDR 128 PIXEL/DEG"
If multiple surfaces are specified, their names
or IDs must be separated by commas.
See the Particulars section below for details
concerning use of DSK data.
The combinations of the shapes of the target bodies
`targ1' and `targ2' must be one of:
One ELLIPSOID, one POINT
Two ELLIPSOIDs
One DSK, one POINT
Case and leading or trailing blanks are not
significant in the string.
frame1 is the name of the body-fixed, body-centered reference
frame associated with the first target body. Examples
of such names are 'IAU_SATURN' (for Saturn) and
'ITRF93' (for the Earth).
[1,c] = size(frame1), char = class(frame1)
If the first target body is modeled as a point, 'frame1'
should be left blank (Ex: ' ').
Case and leading or trailing blanks bracketing a
non-blank frame name are not significant in the string.
target2 is the name of the second target body. See the description
of 'target1' above for more details.
[1,d] = size(target2), char = class(target2)
shape2 is the shape specification for the body designated
by 'target2'. See the description of 'shape1' above for
details.
[1,e] = size(shape2), char = class(shape2)
frame2 is the name of the body-fixed, body-centered reference
frame associated with the second target body. See the
description of 'frame1' above for more details.
[1,f] = size(frame2), char = class(frame2)
abcorr indicates the aberration corrections to be applied to
the state of each target body to account for one-way
light time. Stellar aberration corrections are
ignored if specified, since these corrections don't
improve the accuracy of the occultation determination.
[1,g] = size(abcorr), char = class(abcorr)
See the header of the SPICE routine spkezr_c for a
detailed description of the aberration correction
options. For convenience, the options supported by
this routine are listed below:
'NONE' Apply no correction.
'LT' "Reception" case: correct for
one-way light time using a Newtonian
formulation.
'CN' "Reception" case: converged
Newtonian light time correction.
'XLT' "Transmission" case: correct for
one-way light time using a Newtonian
formulation.
'XCN' "Transmission" case: converged
Newtonian light time correction.
Case and blanks are not significant in the string
'abcorr'.
observer is the name of the body from which the occultation
is observed. See the description of 'target1' for more
details.
[1,h] = size(observer), char = class(observer)
time is the observation time in seconds past the J2000
epoch.
[1,n] = size(time), double = class(time)
the call:
occult_code = cspice_occult ( target1, shape1, frame1, ...
target2, shape2, frame2, ...
abcorr, observer, time )
returns:
occult_code is an integer occultation code indicating the geometric
relationship of the three bodies.
[1,n] = size(occult_code), double = class(occult_code)
The meaning of the sign of 'occult_code' is given below.
Code sign Meaning
--------- ------------------------------
> 0 The second ellipsoid is
partially or fully occulted
by the first.
< 0 The first ellipsoid is
partially of fully
occulted by the second.
= 0 No occultation.
Possible 'occult_code' values and meanings are given
below. The variable names indicate the type of
occultation and which target is in the back. For example,
MICE_OCCULT_TOTAL1_BACK represents a total occultation in
which the first target is in the back (or occulted by)
the second target. The variable names can be used in a
program by calling 'MiceUser' as shown in the
example program below.
Name Code Meaning
------ ----- -----------------------
MICE_OCCULT_TOTAL1_BACK -3 Total occultation of
first target by second.
MICE_OCCULT_ANNLR1_BACK -2 Annular occultation of
first target by second.
The second target does
not block the limb of
the first.
MICE_OCCULT_PARTL1_BACK -1 Partial occultation of
first target by second
target.
MICE_OCCULT_NOOCC 0 No occultation or
transit: both objects
are completely visible
to the observer.
MICE_OCCULT_PARTL2_BACK 1 Partial occultation of
second target by first
target.
MICE_OCCULT_ANNLR2_BACK 2 Annular occultation of
second target by first.
MICE_OCCULT_TOTAL2_BACK 3 Total occultation of
second target by first.
Any numerical results shown for this example may differ between
platforms as the results depend on the SPICE kernels used as input
and the machine specific arithmetic implementation.
Example(1):
Find whether MRO is occulted by Mars as seen by
the DSS-13 ground station at a few specific
times.
KPL/MK
File: mro_ex_occult.tm
This is the meta-kernel file for the example problem for
the subroutine occult_c. These kernel files can be found in
the NAIF archives.
In order for an application to use this meta-kernel, the
kernels referenced here must be present in the user's
current working directory.
The names and contents of the kernels referenced
by this meta-kernel are as follows:
File name Contents
--------- --------
de421.bsp Planetary ephemeris
earthstns_itrf93_050714.bsp DSN station ephemeris
pck00010.tpc Planet orientation and
radii
earth_000101_120409_120117.bpc High precision Earth
orientation
mro_psp_rec.bsp MRO ephemeris
naif0010.tls Leapseconds
earth_topo_050714.tf Topocentric reference
frames for
DSN stations
\begindata
KERNELS_TO_LOAD = ( 'de421.bsp',
'earthstns_itrf93_050714.bsp',
'pck00010.tpc',
'earth_000101_120409_120117.bpc',
'mro_psp_rec.bsp',
'naif0010.tls',
'earth_topo_050714.tf' )
\begintext
End of meta-kernel
Example program starts here.
%
% MiceUser is a file that makes occultation-specific
% variables global. You must call MiceUser to have access to
% these variable names. These variables are defined so you don't
% need to remember what the integer codes mean that the
% occultation routine returns. For more information, please see
% MiceUser.m and MiceOccult.m.
%
MiceUser;
target1 = 'MRO';
shape1 = 'point';
target2 = 'Mars';
shape2 = 'ellipsoid';
observer = 'DSS-13';
dt = 1000;
out_form = '%s %s %s %s wrt %s\n';
out_char = ['totally occulted by ';
'transited by ';
'partially occulted by';
'not occulted by '];
%
% Load the meta kernel.
%
cspice_furnsh ( 'mro_ex_occult.tm' );
et_start = cspice_str2et ( '2012-jan-5 1:15:00 UTC' );
et_stop = cspice_str2et ( '2012-jan-5 2:50:00 UTC' );
for et = et_start : dt : et_stop
%
% Calculate the type of occultation that
% corresponds to time ET.
%
occult_code = cspice_occult ( target1, shape1, ' ', ...
target2, shape2, 'iau_mars', ...
'cn', observer, et );
%
% Output the results.
%
time = cspice_timout ( et, 'YYYY-MM-DD HR:MN ::UTC-8');
%
% Remember: You must call 'MiceUser' before
% using the parameters like 'MICE_OCCULT_TOTAL1_BACK' in
% the case statements below.
%
switch occult_code
case MICE_OCCULT_TOTAL1_BACK
fprintf (out_form, time, target1, out_char(1,:), ...
target2, observer )
case MICE_OCCULT_ANNLR1_BACK
fprintf (out_form, time, target1, out_char(2,:), ...
target2, observer )
case MICE_OCCULT_PARTL1_BACK
fprintf (out_form, time, target1, out_char(3,:), ...
target2, observer )
case MICE_OCCULT_NOOCC
fprintf (out_form, time, target1, out_char(4,:), ...
target2, observer )
case MICE_OCCULT_PARTL2_BACK
fprintf (out_form, time, target2, out_char(3,:), ...
target1, observer )
case MICE_OCCULT_ANNLR2_BACK
fprintf (out_form, time, target2, out_char(2,:), ...
target1, observer )
case MICE_OCCULT_TOTAL2_BACK
fprintf (out_form, time, target2, out_char(1,:), ...
target1, observer )
otherwise
fprintf ( 'Bad occultation code: %d\n', occult_code )
end
end
%
% Unload kernels
%
cspice_kclear
MATLAB outputs:
2012-01-04 17:15 Mars transited by MRO wrt DSS-13
2012-01-04 17:31 MRO not occulted by Mars wrt DSS-13
2012-01-04 17:48 MRO totally occulted by Mars wrt DSS-13
2012-01-04 18:04 MRO totally occulted by Mars wrt DSS-13
2012-01-04 18:21 MRO not occulted by Mars wrt DSS-13
2012-01-04 18:38 Mars transited by MRO wrt DSS-13
For many purposes, modeling extended bodies as triaxial
ellipsoids is adequate for determining whether one body is
occulted by another as seen from a specified observer.
Using DSK data
==============
DSK loading and unloading
-------------------------
DSK files providing data used by this routine are loaded by
calling cspice_furnsh and can be unloaded by calling cspice_unload or
cspice_kclear. See the documentation of cspice_furnsh for limits on
numbers of loaded DSK files.
For run-time efficiency, it's desirable to avoid frequent
loading and unloading of DSK files. When there is a reason to
use multiple versions of data for a given target body---for
example, if topographic data at varying resolutions are to be
used---the surface list can be used to select DSK data to be
used for a given computation. It is not necessary to unload
the data that are not to be used. This recommendation presumes
that DSKs containing different versions of surface data for a
given body have different surface ID codes.
DSK data priority
-----------------
A DSK coverage overlap occurs when two segments in loaded DSK
files cover part or all of the same domain---for example, a
given longitude-latitude rectangle---and when the time
intervals of the segments overlap as well.
When DSK data selection is prioritized, in case of a coverage
overlap, if the two competing segments are in different DSK
files, the segment in the DSK file loaded last takes
precedence. If the two segments are in the same file, the
segment located closer to the end of the file takes
precedence.
When DSK data selection is unprioritized, data from competing
segments are combined. For example, if two competing segments
both represent a surface as a set of triangular plates, the
union of those sets of plates is considered to represent the
surface.
Currently only unprioritized data selection is supported.
Because prioritized data selection may be the default behavior
in a later version of the routine, the UNPRIORITIZED keyword is
required in the `shape1' and `shape2' arguments.
Syntax of the shape input arguments for the DSK case
----------------------------------------------------
The keywords and surface list in the target shape arguments
`shape1' and `shape2' are called "clauses." The clauses may
appear in any order, for example
'DSK/<surface list>/UNPRIORITIZED'
'DSK/UNPRIORITIZED/<surface list>'
'UNPRIORITIZED/<surface list>/DSK'
The simplest form of the `method' argument specifying use of
DSK data is one that lacks a surface list, for example:
'DSK/UNPRIORITIZED'
For applications in which all loaded DSK data for the target
body are for a single surface, and there are no competing
segments, the above string suffices. This is expected to be
the usual case.
When, for the specified target body, there are loaded DSK
files providing data for multiple surfaces for that body, the
surfaces to be used by this routine for a given call must be
specified in a surface list, unless data from all of the
surfaces are to be used together.
The surface list consists of the string
'SURFACES = '
followed by a comma-separated list of one or more surface
identifiers. The identifiers may be names or integer codes in
string format. For example, suppose we have the surface
names and corresponding ID codes shown below:
Surface Name ID code
------------ -------
"Mars MEGDR 128 PIXEL/DEG" 1
"Mars MEGDR 64 PIXEL/DEG" 2
"Mars_MRO_HIRISE" 3
If data for all of the above surfaces are loaded, then
data for surface 1 can be specified by either
'SURFACES = 1'
or
'SURFACES = "Mars MEGDR 128 PIXEL/DEG"'
Double quotes are used to delimit the surface name because
it contains blank characters.
To use data for surfaces 2 and 3 together, any
of the following surface lists could be used:
'SURFACES = 2, 3'
'SURFACES = "Mars MEGDR 64 PIXEL/DEG", 3'
'SURFACES = 2, Mars_MRO_HIRISE'
'SURFACES = "Mars MEGDR 64 PIXEL/DEG", Mars_MRO_HIRISE'
An example of a shape argument that could be constructed
using one of the surface lists above is
'DSK/UNPRIORITIZED/SURFACES = "Mars MEGDR 64 PIXEL/DEG", 3'
For important details concerning this module's function, please refer to
the CSPICE routine occult_c.
MICE.REQ
DSK.REQ
-Mice Version 2.0.0, 04-APR-2017, EDW (JPL), NJB (JPL)
Header update to reflect support for use of DSKs.
-Mice Version 1.0.0, 14-NOV-2013, SCK (JPL)
occultation type at a specified time
|


Amazing Recipes for Every Palate
From the adventurous to the picky eater, you're sure to find something for everyone.
Meals from all Ingredient Classes
We have recipes for every seasonal taste.
Any Time of the Day
Recipes to satisfy your hunger from dawn to dusk.


Vaccinator
About
Hey I am Mayukh, I was tired of checking CoWin for vaccine slots, so being a lazy hacker I made vaccinator.


Jontae Greene's Portfolio
Welcome to my portfolio!
I am Jontae Greene. I am a third year computer science major at Georgia Tech.
I love playing video games, and currently I am playing League of Legends. I mostly play Shyvana and Volibear right now.
Like most people, I would assume, I like animals. Here is a list of some of my favorite animals, in no particular order:
I like taking photographs of moments and places I find beautiful. (Will post pictures later)
I have worked on a number of projects, the one which I am most proud of is Lethe, a Discord bot originally forked from another user, where I updated it and fixed several bugs, eventually turning the bot into something more than what the original owner intended.
Click here to see content created by server code.
Click here to get a random message:
Click here to see a list of uploaded images!


| farver-package {farver} | R Documentation |
The encoding of colour can be handled in many different ways, using different colour spaces. As different colour spaces have different uses, efficient conversion between these representations are important. The 'farver' package provides a set of functions that gives access to very fast colour space conversion and comparisons implemented in C++, and offers speed improvements over the 'convertColor' function in the 'grDevices' package.
Maintainer: Thomas Lin Pedersen<EMAIL_ADDRESS>(ORCID)
Authors:
Berendea Nicolae (Author of the ColorSpace C++ library)
Romain François<EMAIL_ADDRESS>(ORCID)
Useful links:
Report bugs at https://github.com/thomasp85/farver/issues


--- layout: post title: 'Casuality Europe: Impressions so far' date: 2006-02-08 00:00:00 categories: business mobile personal play ---
There seems to be a strong US focus here, and - perhaps coincidentally - a broader use of the "casual game" term than what I'm used to. Certain console and PC titles seem to fall under this category, which surprises me as I can't really see how anything could be less casual than a gaming session sat at a screen. Suspect this may be due to wearing mobile-shaped blinkers for half a decade.
At other events I've been to, the tone has been a rather unrealistic "how do we get around those pesky operators". There seems to be a bit more realism here: "you may not like the operators but you don't have much of a choice but to work with them... today".
I've enjoyed all the talks I've been to so far. "Alternate business models for mobile" didn't really reveal any fantastic new models as such, but it was great to hear experiences from aggregators, developers, and media companies trying to get commercially successful in this area.
The event seems very developer-oriented.


Connect JIFF
Computation ID
Party Count
Connect
Binary Search Tree
Enter an array of positive integers.
[1,3,2]
Submit
Open Tree
Value:
Find
Please do the same query as the other parties.


const ( // MinimumExpirationWarningInterval is the default minimum time interval // between consecutive warnings about certificate expiration. MinimumExpirationWarningInterval = time.Minute * 5 )
const ( // RetryTimeout is the time the block puller retries. RetryTimeout = time.Second * 10 )
var ( EgressQueueLengthOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "egress_queue_length", Help: "Length of the egress queue.", LabelNames: []string{"host", "msg_type", "channel"}, StatsdFormat: "%{#fqname}.%{host}.%{msg_type}.%{channel}", } EgressQueueCapacityOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "egress_queue_capacity", Help: "Capacity of the egress queue.", LabelNames: []string{"host", "msg_type", "channel"}, StatsdFormat: "%{#fqname}.%{host}.%{msg_type}.%{channel}", } EgressWorkersOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "egress_queue_workers", Help: "Count of egress queue workers.", LabelNames: []string{"channel"}, StatsdFormat: "%{#fqname}.%{channel}", } IngressStreamsCountOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "ingress_stream_count", Help: "Count of streams from other nodes.", StatsdFormat: "%{#fqname}", } EgressStreamsCountOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "egress_stream_count", Help: "Count of streams to other nodes.", LabelNames: []string{"channel"}, StatsdFormat: "%{#fqname}.%{channel}", } EgressTLSConnectionCountOpts = metrics.GaugeOpts{ Namespace: "cluster", Subsystem: "comm", Name: "egress_tls_connection_count", Help: "Count of TLS connections to other nodes.", StatsdFormat: "%{#fqname}", } MessageSendTimeOpts = metrics.HistogramOpts{ Namespace: "cluster", Subsystem: "comm", Name: "msg_send_time", Help: "The time it takes to send a message in seconds.", LabelNames: []string{"host", "channel"}, StatsdFormat: "%{#fqname}.%{host}.%{channel}", } MessagesDroppedCountOpts = metrics.CounterOpts{ Namespace: "cluster", Subsystem: "comm", Name: "msg_dropped_count", Help: "Count of messages dropped.", LabelNames: []string{"host", "channel"}, StatsdFormat: "%{#fqname}.%{host}.%{channel}", } )
ErrForbidden denotes that an ordering node refuses sending blocks due to access control.
var ErrForbidden = errors.New("forbidden pulling the channel")
ErrNotInChannel denotes that an ordering node is not in the channel
var ErrNotInChannel = errors.New("not in the channel")
var ErrRetryCountExhausted = errors.New("retry attempts exhausted")
ErrServiceUnavailable denotes that an ordering node is not servicing at the moment.
var errors.New("service unavailable")=
ErrSkipped denotes that replicating a chain was skipped
var ErrSkipped = errors.New("skipped")
func AnyChannel(_ string) bool
AnyChannel accepts all channels.
func BlockToString(block *common.Block) string
BlockToString returns a string representation of this block.
func ChannelCreationBlockToGenesisBlock(block *common.Block) (*common.Block, error)
ChannelCreationBlockToGenesisBlock converts a channel creation block to a genesis block
func ConfigFromBlock(block *common.Block) (*common.ConfigEnvelope, error)
ConfigFromBlock returns a ConfigEnvelope if exists, or a *NotAConfigBlock error. It may also return some other error in case parsing failed.
func DERtoPEM(der []byte) string
DERtoPEM returns a PEM representation of the DER encoded certificate
func IsNewChannelBlock(block *common.Block) (string, error)
IsNewChannelBlock returns a name of the channel in case it holds a channel create transaction, or empty string otherwise.
func LastConfigBlock(block *common.Block, blockRetriever BlockRetriever) (*common.Block, error)
LastConfigBlock returns the last config block relative to the given block.
func NewStreamsByType() map[OperationType]map[uint64]*Stream
NewStreamsByType returns a mapping of operation type to a mapping of destination to stream.
func Participant(puller ChainPuller, analyzeLastConfBlock SelfMembershipPredicate) error
Participant returns whether the caller participates in the chain. It receives a ChainPuller that should already be calibrated for the chain, and a SelfMembershipPredicate that is used to detect whether the caller should service the chain. It returns nil if the caller participates in the chain. It may return: ErrNotInChannel in case the caller doesn't participate in the chain. ErrForbidden in case the caller is forbidden from pulling the block. ErrServiceUnavailable in case all orderers reachable cannot complete the request. ErrRetryCountExhausted in case no orderer is reachable.
func PullLastConfigBlock(puller ChainPuller) (*common.Block, error)
PullLastConfigBlock pulls the last configuration block, or returns an error on failure.
func SignatureSetFromBlock(block *common.Block) ([]*common.SignedData, error)
SignatureSetFromBlock creates a signature set out of a block.
func VerifyBlockHash(indexInBuffer int, blockBuff []*common.Block) error
VerifyBlockHash verifies the hash chain of the block with the given index among the blocks of the given block buffer.
func VerifyBlockSignature(block *common.Block, verifier BlockVerifier, config *common.ConfigEnvelope) error
VerifyBlockSignature verifies the signature on the block with the given BlockVerifier and the given config.
func VerifyBlocks(blockBuff []*common.Block, signatureVerifier BlockVerifier) error
VerifyBlocks verifies the given consecutive sequence of blocks is valid, and returns nil if it's valid, else an error.
BlockCommitFunc signals a block commit.
type BlockCommitFunc func(block *common.Block, channel string)
BlockPuller pulls blocks from remote ordering nodes. Its operations are not thread safe.
type BlockPuller struct { // Configuration MaxPullBlockRetries uint64 MaxTotalBufferBytes int Signer crypto.LocalSigner TLSCert []byte Channel string FetchTimeout time.Duration RetryTimeout time.Duration Logger *flogging.FabricLogger Dialer Dialer VerifyBlockSequence BlockSequenceVerifier Endpoints []EndpointCriteria // contains filtered or unexported fields }
func BlockPullerFromConfigBlock(conf PullerConfig, block *common.Block, verifierRetriever VerifierRetriever) (*BlockPuller, error)
BlockPullerFromConfigBlock returns a BlockPuller that doesn't verify signatures on blocks.
func (p *BlockPuller) Clone() *BlockPuller
Clone returns a copy of this BlockPuller initialized for the given channel
func (p *BlockPuller) Close()
Close makes the BlockPuller close the connection and stream with the remote endpoint, and wipe the internal block buffer.
func (p *BlockPuller) HeightsByEndpoints() (map[string]uint64, error)
HeightsByEndpoints returns the block heights by endpoints of orderers
func (p *BlockPuller) PullBlock(seq uint64) *common.Block
PullBlock blocks until a block with the given sequence is fetched from some remote ordering node, or until consecutive failures of fetching the block exceed MaxPullBlockRetries.
 Block(number uint64) *common.Block }
BlockSequenceVerifier verifies that the given consecutive sequence of blocks is valid.
type BlockSequenceVerifier func(blocks []*common.Block, channel string) error
BlockValidationPolicyVerifier verifies signatures based on the block validation policy.
type BlockValidationPolicyVerifier struct { Logger *flogging.FabricLogger Channel string PolicyMgr policies.Manager }
func (bv *BlockValidationPolicyVerifier) VerifyBlockSignature(sd []*common.SignedData, envelope *common.ConfigEnvelope) error
VerifyBlockSignature verifies the signed data associated to a block, optionally with the given config envelope.
BlockVerifier verifies block signatures.
type BlockVerifier interface { // VerifyBlockSignature verifies a signature of a block. // It has an optional argument of a configuration envelope // which would make the block verification to use validation rules // based on the given configuration in the ConfigEnvelope. // If the config envelope passed is nil, then the validation rules used // are the ones that were applied at commit of previous blocks. VerifyBlockSignature(sd []*common.SignedData, config *common.ConfigEnvelope) error }
BlockVerifierAssembler creates a BlockVerifier out of a config envelope
type BlockVerifierAssembler struct { Logger *flogging.FabricLogger }
func (bva *BlockVerifierAssembler) VerifierFromConfig(configuration *common.ConfigEnvelope, channel string) (BlockVerifier, error)
VerifierFromConfig creates a BlockVerifier from the given configuration.
ChainInspector walks over a chain
type ChainInspector struct { Logger *flogging.FabricLogger Puller ChainPuller LastConfigBlock *common.Block }
func (ci *ChainInspector) Channels() []ChannelGenesisBlock
Channels returns the list of ChannelGenesisBlocks for all channels. Each such ChannelGenesisBlock contains the genesis block of the channel.
func (ci *ChainInspector) Close()
Close closes the ChainInspector
ChainPuller pulls blocks from a chain
type ChainPuller interface { // PullBlock pulls the given block from some orderer node PullBlock(seq uint64) *common.Block // HeightsByEndpoints returns the block heights by endpoints of orderers HeightsByEndpoints() (map[string]uint64, error) // Close closes the ChainPuller Close() }
ChannelExtractor extracts the channel of a given message, or returns an empty string if that's not possible
type ChannelExtractor interface { TargetChannel(message proto.Message) string }
ChannelGenesisBlock wraps a Block and its channel name
type ChannelGenesisBlock struct { ChannelName string GenesisBlock *common.Block }
ChannelLister returns a list of channels
type ChannelLister interface { // Channels returns a list of channels Channels() []ChannelGenesisBlock // Close closes the ChannelLister Close() }
ChannelPredicate accepts channels according to their names.
type ChannelPredicate func(channelName string) bool
ClusterClient creates streams that point to a remote cluster member.
type ClusterClient interface { Step(ctx context.Context, opts ...grpc.CallOption) (orderer.Cluster_StepClient, error) }
Comm implements Communicator
type Comm struct { MinimumExpirationWarningInterval time.Duration CertExpWarningThreshold time.Duration SendBufferSize int Lock sync.RWMutex Logger *flogging.FabricLogger ChanExt ChannelExtractor H Handler Connections *ConnectionStore Chan2Members MembersByChannel Metrics *Metrics // contains filtered or unexported fields }
func (c *Comm) Configure(channel string, newNodes []RemoteNode)
Configure configures the channel with the given RemoteNodes
func (c *Comm) DispatchConsensus(ctx context.Context, request *orderer.ConsensusRequest) error
DispatchConsensus identifies the channel and sender of the step request and passes it to the underlying Handler
func (c *Comm) DispatchSubmit(ctx context.Context, request *orderer.SubmitRequest) error
DispatchSubmit identifies the channel and sender of the submit request and passes it to the underlying Handler
func (c *Comm) Remote(channel string, id uint64) (*RemoteContext, error)
Remote obtains a RemoteContext linked to the destination node on the context of a given channel
func (c *Comm) Shutdown()
Shutdown shuts down the instance
Communicator defines communication for a consenter
type Communicator interface { // Remote returns a RemoteContext for the given RemoteNode ID in the context // of the given channel, or error if connection cannot be established, or // the channel wasn't configured Remote(channel string, id uint64) (*RemoteContext, error) // Configure configures the communication to connect to all // given members, and disconnect from any members not among the given // members. Configure(channel string, members []RemoteNode) // Shutdown shuts down the communicator Shutdown() }
ConnByCertMap maps certificates represented as strings to gRPC connections
type ConnByCertMap map[string]*grpc.ClientConn
func (cbc ConnByCertMap) Lookup(cert []byte) (*grpc.ClientConn, bool)
Lookup looks up a certificate and returns the connection that was mapped to the certificate, and whether it was found or not
func (cbc ConnByCertMap) Put(cert []byte, conn *grpc.ClientConn)
Put associates the given connection to the certificate
func (cbc ConnByCertMap) Remove(cert []byte)
Remove removes the connection that is associated to the given certificate
func (cbc ConnByCertMap) Size() int
ConnectionMapper maps certificates to connections
type ConnectionMapper interface { Lookup(cert []byte) (*grpc.ClientConn, bool) Put(cert []byte, conn *grpc.ClientConn) Remove(cert []byte) Size() int }
ConnectionStore stores connections to remote nodes
type ConnectionStore struct { Connections ConnectionMapper // contains filtered or unexported fields }
func NewConnectionStore(dialer SecureDialer, tlsConnectionCount metrics.Gauge) *ConnectionStore
NewConnectionStore creates a new ConnectionStore with the given SecureDialer
func (c *ConnectionStore) Connection(endpoint string, expectedServerCert []byte) (*grpc.ClientConn, error)
Connection obtains a connection to the given endpoint and expects the given server certificate to be presented by the remote node
func (c *ConnectionStore) Disconnect(expectedServerCert []byte)
Disconnect closes the gRPC connection that is mapped to the given certificate
Dialer creates a gRPC connection to a remote address
type Dialer interface { Dial(endpointCriteria EndpointCriteria) (*grpc.ClientConn, error) }
Dispatcher dispatches requests
type Dispatcher interface { DispatchSubmit(ctx context.Context, request *orderer.SubmitRequest) error DispatchConsensus(ctx context.Context, request *orderer.ConsensusRequest) error }
EndpointCriteria defines criteria of how to connect to a remote orderer node.
type EndpointCriteria struct { Endpoint string // Endpoint of the form host:port TLSRootCAs [][]byte // PEM encoded TLS root CA certificates }
func EndpointconfigFromConfigBlock(block *common.Block) ([]EndpointCriteria, error)
EndpointconfigFromConfigBlock retrieves TLS CA certificates and endpoints from a config block.
GenesisBlocks aggregates several ChannelGenesisBlocks
type GenesisBlocks []ChannelGenesisBlock
func (gbs GenesisBlocks) Names() []string
Names returns the channel names all ChannelGenesisBlocks
Handler handles Step() and Submit() requests and returns a corresponding response
type Handler interface { OnConsensus(channel string, sender uint64, req *orderer.ConsensusRequest) error OnSubmit(channel string, sender uint64, req *orderer.SubmitRequest) error }
ImpatientStream aborts the stream if it waits for too long for a message.
type ImpatientStream struct { orderer.AtomicBroadcast_DeliverClient // contains filtered or unexported fields }
func (stream *ImpatientStream) Recv() (*orderer.DeliverResponse, error)
Recv blocks until a response is received from the stream or the timeout expires.
ImpatientStreamCreator creates an ImpatientStream
type ImpatientStreamCreator func() (*ImpatientStream, error)
func NewImpatientStream(conn *grpc.ClientConn, waitTimeout time.Duration) ImpatientStreamCreator
NewImpatientStream returns a ImpatientStreamCreator that creates impatientStreams.
LedgerFactory retrieves or creates new ledgers by chainID
type LedgerFactory interface { // GetOrCreate gets an existing ledger (if it exists) // or creates it if it does not GetOrCreate(chainID string) (LedgerWriter, error) }
LedgerInterceptor intercepts block commits.
type LedgerInterceptor struct { Channel string InterceptBlockCommit BlockCommitFunc LedgerWriter }
func (interceptor *LedgerInterceptor) Append(block *common.Block) error
Append commits a block into the ledger, and also fires the configured callback.
LedgerWriter allows the caller to write blocks and inspect the height
type LedgerWriter interface { // Append a new block to the ledger Append(block *common.Block) error // Height returns the number of blocks on the ledger Height() uint64 }
MemberMapping defines NetworkMembers by their ID
type MemberMapping map[uint64]*Stub
func (mp MemberMapping) ByID(ID uint64) *Stub
ByID retrieves the Stub with the given ID from the MemberMapping
func (mp MemberMapping) LookupByClientCert(cert []byte) *Stub
LookupByClientCert retrieves a Stub with the given client certificate
func (mp MemberMapping) Put(stub *Stub)
Put inserts the given stub to the MemberMapping
func (mp MemberMapping) ServerCertificates() StringSet
ServerCertificates returns a set of the server certificates represented as strings
MembersByChannel is a mapping from channel name to MemberMapping
type MembersByChannel map[string]MemberMapping
Metrics defines the metrics for the cluster.
type Metrics struct { EgressQueueLength metrics.Gauge EgressQueueCapacity metrics.Gauge EgressWorkerCount metrics.Gauge IngressStreamsCount metrics.Gauge EgressStreamsCount metrics.Gauge EgressTLSConnectionCount metrics.Gauge MessageSendTime metrics.Histogram MessagesDroppedCount metrics.Counter }
func NewMetrics(provider MetricsProvider) *Metrics
NewMetrics initializes new metrics for the cluster infrastructure.
A MetricsProvider is an abstraction for a metrics provider. It is a factory for Counter, Gauge, and Histogram meters.
type MetricsProvider interface { // NewCounter creates a new instance of a Counter. NewCounter(opts metrics.CounterOpts) metrics.Counter // NewGauge creates a new instance of a Gauge. NewGauge(opts metrics.GaugeOpts) metrics.Gauge // NewHistogram creates a new instance of a Histogram. NewHistogram(opts metrics.HistogramOpts) metrics.Histogram }
NoopBlockVerifier doesn't verify block signatures
type NoopBlockVerifier struct{}
func (*NoopBlockVerifier) VerifyBlockSignature(sd []*common.SignedData, config *common.ConfigEnvelope) error
VerifyBlockSignature accepts all signatures over blocks.
OperationType denotes a type of operation that the RPC can perform such as sending a transaction, or a consensus related message.
type OperationType int
const ( ConsensusOperation OperationType = iota SubmitOperation )
PredicateDialer creates gRPC connections that are only established if the given predicate is fulfilled
type PredicateDialer struct { comm.ClientConfig // contains filtered or unexported fields }
func (dialer *PredicateDialer) Dial(address string, verifyFunc RemoteVerifier) (*grpc.ClientConn, error)
Dial creates a new gRPC connection that can only be established, if the remote node's certificate chain satisfy verifyFunc
func (dialer *PredicateDialer) UpdateRootCAs(serverRootCAs [][]byte)
PullerConfig configures a BlockPuller.
type PullerConfig struct { TLSKey []byte TLSCert []byte Timeout time.Duration Signer crypto.LocalSigner Channel string MaxTotalBufferBytes int }
func PullerConfigFromTopLevelConfig(systemChannel string, conf *localconfig.TopLevel, tlsKey, tlsCert []byte, signer crypto.LocalSigner) PullerConfig
PullerConfigFromTopLevelConfig creates a PullerConfig from a TopLevel config, and from a signer and TLS key cert pair. The PullerConfig's channel is initialized to be the system channel.
RPC performs remote procedure calls to remote cluster nodes.
type RPC struct { Logger *flogging.FabricLogger Timeout time.Duration Channel string Comm Communicator StreamsByType map[OperationType]map[uint64]*Stream // contains filtered or unexported fields }
func (s *RPC) SendConsensus(destination uint64, msg *orderer.ConsensusRequest) error
Consensus passes the given ConsensusRequest message to the raft.Node instance.
func (s *RPC) SendSubmit(destination uint64, request *orderer.SubmitRequest) error
SendSubmit sends a SubmitRequest to the given destination node.
RemoteContext interacts with remote cluster nodes. Every call can be aborted via call to Abort()
type RemoteContext struct { Metrics *Metrics Channel string SendBuffSize int Logger *flogging.FabricLogger Client orderer.ClusterClient ProbeConn func(conn *grpc.ClientConn) error // contains filtered or unexported fields }
func (rc *RemoteContext) Abort()
Abort aborts the contexts the RemoteContext uses, thus effectively causes all operations that use this RemoteContext to terminate.
func (rc *RemoteContext) NewStream(timeout time.Duration) (*Stream, error)
NewStream creates a new stream. It is not thread safe, and Send() or Recv() block only until the timeout expires.
RemoteNode represents a cluster member
type RemoteNode struct { // ID is unique among all members, and cannot be 0. ID uint64 // Endpoint is the endpoint of the node, denoted in %s:%d format Endpoint string // ServerTLSCert is the DER encoded TLS server certificate of the node ServerTLSCert []byte // ClientTLSCert is the DER encoded TLS client certificate of the node ClientTLSCert []byte }
func (rm RemoteNode) String() string
String returns a string representation of this RemoteNode
RemoteVerifier verifies the connection to the remote host
type RemoteVerifier func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error
Replicator replicates chains
type Replicator struct { DoNotPanicIfClusterNotReachable bool Filter ChannelPredicate SystemChannel string ChannelLister ChannelLister Logger *flogging.FabricLogger Puller *BlockPuller BootBlock *common.Block AmIPartOfChannel SelfMembershipPredicate LedgerFactory LedgerFactory }
func (r *Replicator) IsReplicationNeeded() (bool, error)
IsReplicationNeeded returns whether replication is needed, or the cluster node can resume standard boot flow.
func (r *Replicator) PullChannel(channel string) error
PullChannel pulls the given channel from some orderer, and commits it to the ledger.
func (r *Replicator) ReplicateChains() []string
ReplicateChains pulls chains and commits them. Returns the names of the chains replicated successfully.
SecureDialer connects to a remote address
type SecureDialer interface { Dial(address string, verifyFunc RemoteVerifier) (*grpc.ClientConn, error) }
SelfMembershipPredicate determines whether the caller is found in the given config block
type SelfMembershipPredicate func(configBlock *common.Block) error
Service defines the raft Service
type Service struct { StreamCountReporter *StreamCountReporter Dispatcher Dispatcher Logger *flogging.FabricLogger StepLogger *flogging.FabricLogger MinimumExpirationWarningInterval time.Duration CertExpWarningThreshold time.Duration }
func (s *Service) Step(stream orderer.Cluster_StepServer) error
Step passes an implementation-specific message to another cluster member.
StandardDialer wraps an AtomicClientConfig, and provides a means to connect according to given EndpointCriteria.
type StandardDialer struct { comm.ClientConfig }
func (dialer *StandardDialer) Dial(endpointCriteria EndpointCriteria) (*grpc.ClientConn, error)
Dial dials an address according to the given EndpointCriteria
StepClient defines a client that sends and receives Step requests and responses.
type StepClient interface { Send(*orderer.StepRequest) error Recv() (*orderer.StepResponse, error) grpc.ClientStream }
StepStream defines the gRPC stream for sending transactions, and receiving corresponding responses
type StepStream interface { Send(response *orderer.StepResponse) error Recv() (*orderer.StepRequest, error) grpc.ServerStream }
Stream is used to send/receive messages to/from the remote cluster member.
type Stream struct { ID uint64 Channel string NodeName string Endpoint string Logger *flogging.FabricLogger Timeout time.Duration orderer.Cluster_StepClient Cancel func(error) // contains filtered or unexported fields }
func (stream *Stream) Canceled() bool
Canceled returns whether the stream was canceled.
func (stream *Stream) Recv() (*orderer.StepResponse, error)
Recv receives a message from a remote cluster member.
func (stream *Stream) Send(request *orderer.StepRequest) error
Send sends the given request to the remote cluster member.
StreamCountReporter reports the number of streams currently connected to this node
type StreamCountReporter struct { Metrics *Metrics // contains filtered or unexported fields }
func (scr *StreamCountReporter) Decrement()
func (scr *StreamCountReporter) Increment()
StreamOperation denotes an operation done by a stream, such a Send or Receive.
type StreamOperation func() (*orderer.StepResponse, error)
StringSet is a set of strings
type StringSet map[string]struct{}
Stub holds all information about the remote node, including the RemoteContext for it, and serializes some operations on it.
type Stub struct { RemoteNode *RemoteContext // contains filtered or unexported fields }
func (stub *Stub) Activate(createRemoteContext func() (*RemoteContext, error)) error
Activate creates a remote context with the given function callback in an atomic manner - if two parallel invocations are invoked on this Stub, only a single invocation of createRemoteStub takes place.
func (stub *Stub) Active() bool
Active returns whether the Stub is active or not
func (stub *Stub) Deactivate()
Deactivate deactivates the Stub and ceases all communication operations invoked on it.
VerificationRegistry registers verifiers and retrieves them.
type VerificationRegistry struct { LoadVerifier func(chain string) BlockVerifier Logger *flogging.FabricLogger VerifierFactory VerifierFactory VerifiersByChannel map[string]BlockVerifier }
func (vr *VerificationRegistry) BlockCommitted(block *common.Block, channel string)
BlockCommitted notifies the VerificationRegistry upon a block commit, which may trigger a registration of a verifier out of the block in case the block is a config block.
func (vr *VerificationRegistry) RegisterVerifier(chain string)
RegisterVerifier adds a verifier into the registry if applicable.
func (vr *VerificationRegistry) RetrieveVerifier(channel string) BlockVerifier
RetrieveVerifier returns a BlockVerifier for the given channel, or nil if not found.
VerifierFactory creates BlockVerifiers.
type VerifierFactory interface { // VerifierFromConfig creates a BlockVerifier from the given configuration. VerifierFromConfig(configuration *common.ConfigEnvelope, channel string) (BlockVerifier, error) }
VerifierRetriever retrieves BlockVerifiers for channels.
type VerifierRetriever interface { // RetrieveVerifier retrieves a BlockVerifier for the given channel. RetrieveVerifier(channel string) BlockVerifier }


Use WASD or arrow keys to move the snake. If you want to change the canvas size, resize your browser.
Your length is:
5
Reset
Start
Very Slow
Slow
Medium
Medium-fast
Faster
For AI-> Fast
For AI-> Very Fast
DFS
BFS
A*
Hamiltonian: Optimal


CKBCOMP(1) Console-setup User's Manual CKBCOMP(1) NAME ckbcomp - compile a XKB keyboard description to a keymap suitable for loadkeys or kbdcontrol SYNOPSIS ckbcomp [OPTION...] [XKBLAYOUT [XKBVARIANT [XKBOPTIONS]...]] DESCRIPTION The ckbcomp keymap compiler converts a description of an XKB keyboard layout into a console keymap that can be read directly by loadkeys(1) or kbdcontrol(1). On its standard output ckbcomp dumps the generated keyboard definition. The most important difference between the arguments of setxkbmap(1) and the arguments of ckbcomp is the additional parameter -charmap when non- Unicode keyboard map is wanted. Without -charmap ckbcomp will generate Unicode keyboard. OPTIONS General options -?,-help Print a usage message and exit. -charmap charmap The encoding to use for the output keymap. There should be an character mapping table defining this encoding in /usr/share/con‐ soletrans. Definitions of the following charmaps are provided: ARMSCII-8, CP1251, CP1255, CP1256, GEORGIAN-ACADEMY, GEORGIAN-PS, IBM1133, ISIRI-3342, ISO-8859-1, ISO-8859-2, ISO-8859-3, ISO-8859-4, ISO-8859-5, ISO-8859-6, ISO-8859-7, ISO-8859-8, ISO-8859-9, ISO-8859-10, ISO-8859-11, ISO-8859-13, ISO-8859-14, ISO-8859-15, ISO-8859-16, KOI8-R, KOI8-U, TIS-620 and VISCII. -Idir Look in the top-level directory dir for files included by the keymap description. This option may be used multiple times. If a file can not be found in any of the specified directories, it will be searched also in some other standard locations, such as /etc/console-setup/ckb, /usr/share/X11/xkb and /etc/X11/xkb -v level Set level of detail for listing. The argument level must be a number from 1 to 10. -compact Generate a compact keymap with at most two xkb groups and two lev‐ els in each or only one xkb-group and up to four levels. -freebsd Generate a keymap for FreeBSD. -backspace [bs|del] Specifies the behaviour of the <BackSpace> and <Delete> keys. Val‐ ue bs specifies VT100-conformant behaviour: <BackSpace> will gen‐ erate ^H (ASCII BS) and <Delete> will generate ^? (ASCII DEL). Value del specifies VT220-conformant behavior: <BackSpace> will generate ^? (ASCII DEL) and <Delete> will generate a special function sequence. XKB Keyboard Description The keyboard layout, variant and options components can be also specified directly on the command line. See the synopsis of the command. -symbols name Specifies the symbols component name of the XKB keyboard descrip‐ tion. -keycodes name Specifies the keycodes component name of the XKB keyboard descrip‐ tion. -rules name The name of the rules file to use. -model name Specifies the keyboard model used to choose the component names. -layout name Specifies the layout used to choose the component names. -variant name Specifies the layout variant used to choose the component names. -option name Adds an option used to choose component names. FILES /usr/share/consoletrans /etc/console-setup/ckb /usr/share/X11/xkb /etc/X11/xkb NOTES If the option -freebsd is used together with -backspace del, then the key <Delete> will generate the special code fkey70. It is your responsibili‐ ty to assign the appropriate sequence to this special code by using the following command: kbdcontrol -f 70 "`printf '\033[3~'`" SEE ALSO keyboard(5), setxkbmap(1) console-setup 2011-03-17 CKBCOMP(1)