Post on 11-Jan-2016
transcript
Lecture Grids and Markup Languages
Gregor von Laszewski
Argonne National Laboratory
and
University of Chicago
gregor@mcs.anl.gov
http://www.mcs.anl.gov/~gregor
Outline Gestalt of the Grid State of the Grid Example for a production Grid Markup Languages Example Query
Gestalt of the Grid We start the discussion with a famous picture used in
early psychology experiments. If we examine the drawing in detail, it will be rather
difficult to decide what the different components represent in each of the interpretations. Although hat, feather, and ear are identifiable in the figure, one’s interpretation (Is it an old woman or a young girl?) is based instead on “perceptual evidence.”
This figure should remind us to be open to individual perceptions about Grids and to be aware of the multifaceted aspects that constitute the Gestalt of the Grid.
Motivation: Perform Collaborative Multiscale Science
observationsobservations modelmodel predictionprediction
feedbackfeedback
consumerconsumersensorssensors compute and storagecompute and storagefacilitiesfacilities
scientistsscientists
calculatecalculatecollaboratecollaboratemeasuremeasure deliverdeliver
• von Laszewski, et al. Gestalt of the Grid, http://www.mcs.anl.gov/~gregor/von Laszewski, et al. Gestalt of the Grid, http://www.mcs.anl.gov/~gregor/
The motivating experiment at ANL Virtual Lecture Room
Grid
Scientist
Advanced Photon Source
Electronic Library and Databases
Grid: an evolving term (1)
Kleinrock 1969: We will probably see the spread of computer utilities, which, like
present electric and telephone utilities, will service individual homes and offices across the country.
90s: Prior to using the term Grid Catlett: pre 1996 metacomputer Foster: 1996 networked supercomputing environment von Laszewski: 1996 integration of knowledge resources (= data &
humans) into the networked
1999: The Grid Book A computational Grid is a hardware and software infrastructure
that provides dependable, consistent, pervasive, and inexpensive access to high-end computational capabilities
Limits definition to hardware and software infrastructure
Grid: an evolving term (2)
2000 von Laszewski: Grid approach We define the Grid approach as a general concept and idea to
promote a vision for sophisticated international scientific and business-oriented collaborations.
A Grid is the infrastructure that makes the Grid approach a reality. A production Grid is a shared computing infrastructure of
hardware, software, and knowledge resources that allows the coordinated resource sharing and problem solving in dynamic, multi-institutional virtual organizations to enable sophisticated international scientific and business-oriented collaborations
An ad hoc Grid provides a production Grid that addresses management issues related to sporadic, ad hoc, and time-limited interactions and collaborations including the instantiation and management of the production Grid itself.
Grid Building a collaborative environment to share resources Provide the users with an impression of a persistent
infrastructure Virtualize the concept of a resource Virtualize the concept of groups sharing the
History of Globus and CoG at ANL
Management Challenge Users requirements result in a variety of complex
challenges They will keep us busy for quite a while We should not expect the solution to be here tomorrow
or that it was here yesterday.
Grid Management Aspects
Software/Application
Service
HardwareInfrastructure
Tasks
Data
Information
Communities
GridManagement
Compatibility
Inter-operability
Unpre-dictability
Dynamicity Dispersity
Distribution
Quality
Hetero-genity
Security
Information
Delegation
SingleSignOn
CommunityAuthorization
Non-Repudations
Encryption
Authorization
Authentication
Security
Information Security
…
Secure communication through encryption and non-repudiationAccess control
through authenticationand authorization
Single Sign-on
Secure Execution
Authorization
Authentication
Communityauthorization
Delegation
Subset of Grid related Security Concepts
Grid computing must address integration challenge
Grid deployments and software releases
Grid Computing is more than middleware Grid computing must be seamlessly integrated in
commodity technologies to be effective
Evolution invariant architectures
Longevity is bound to evolution invariant architectures
Visual Interfaces / Grid faces Education need easy access to lower barrier
Rapid Prototyping: Job Submissioncallback_func(void *user_arg, char *job_contact,
int state, int errorcode){ globus_i_globusrun_gram_monitor_t *monitor; monitor = (globus_i_globusrun_gram_monitor_t *) user_arg; globus_mutex_lock(&monitor->mutex); monitor->job_state = state; switch(state) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING:{ globus_i_globusrun_gram_monitor_t *monitor; monitor = (globus_i_globusrun_gram_monitor_t *) user_arg; globus_mutex_lock(&monitor->mutex); monitor->job_state = state; switch(state) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED: if(monitor->verbose)
{ globus_libc_printf("GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED\n");
} monitor->done = GLOBUS_TRUE; break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE: if(monitor->verbose)
{ globus_libc_printf("GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE\n");
} monitor->done = GLOBUS_TRUE; break; } globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex);}
callback_func(void *user_arg, char *job_contact, int state, int errorcode){ globus_i_globusrun_gram_monitor_t *monitor; monitor = (globus_i_globusrun_gram_monitor_t *) user_arg; globus_mutex_lock(&monitor->mutex); monitor->job_state = state; switch(state) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING:{ globus_i_globusrun_gram_monitor_t *monitor; monitor = (globus_i_globusrun_gram_monitor_t *) user_arg; globus_mutex_lock(&monitor->mutex); monitor->job_state = state; switch(state) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED: if(monitor->verbose)
{ globus_libc_printf("GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED\n");
} monitor->done = GLOBUS_TRUE; break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE: if(monitor->verbose)
{ globus_libc_printf("GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE\n");
} monitor->done = GLOBUS_TRUE; break; } globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex);}
globus_l_globusrun_gramrun(char * request_string, unsigned long options, char *rm_contact){ char *callback_contact = GLOBUS_NULL; char *job_contact = GLOBUS_NULL; globus_i_globusrun_gram_monitor_t monitor; int err; monitor.done = GLOBUS_FALSE; monitor.verbose=verbose; globus_mutex_init(&monitor.mutex, GLOBUS_NULL); globus_cond_init(&monitor.cond, GLOBUS_NULL);
err = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if(err != GLOBUS_SUCCESS) { … } err = globus_gram_client_callback_allow( globus_l_globusrun_gram_callback_func, (void *) &monitor, &callback_contact); if(err != GLOBUS_SUCCESS) { … } err = globus_gram_client_job_request(rm_contact, request_string, GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL, callback_contact, &job_contact); if(err != GLOBUS_SUCCESS) { … } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); globus_gram_client_callback_disallow(callback_contact); globus_free(callback_contact);
globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond);
globus_l_globusrun_gramrun(char * request_string, unsigned long options, char *rm_contact){ char *callback_contact = GLOBUS_NULL; char *job_contact = GLOBUS_NULL; globus_i_globusrun_gram_monitor_t monitor; int err; monitor.done = GLOBUS_FALSE; monitor.verbose=verbose; globus_mutex_init(&monitor.mutex, GLOBUS_NULL); globus_cond_init(&monitor.cond, GLOBUS_NULL);
err = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if(err != GLOBUS_SUCCESS) { … } err = globus_gram_client_callback_allow( globus_l_globusrun_gram_callback_func, (void *) &monitor, &callback_contact); if(err != GLOBUS_SUCCESS) { … } err = globus_gram_client_job_request(rm_contact, request_string, GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL, callback_contact, &job_contact); if(err != GLOBUS_SUCCESS) { … } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); globus_gram_client_callback_disallow(callback_contact); globus_free(callback_contact);
globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond);
•// Check whether you can submit a job to a particular // Check whether you can submit a job to a particular gatekeeper.gatekeeper.
Gram.ping( proxy, “hot.mcs.anl.gov”);Gram.ping( proxy, “hot.mcs.anl.gov”);
•// Create a job// Create a job
GramJob job = new GramJob(proxy, rsl.toRSL());GramJob job = new GramJob(proxy, rsl.toRSL());
•// Add a status change listener// Add a status change listenerclass GramJobListenerImpl class GramJobListenerImpl implements GramJobListener {implements GramJobListener { public void statusChanged(GramJob job) { public void statusChanged(GramJob job) { String status = job.getStatusAsString(); String status = job.getStatusAsString(); System.out.println(status); System.out.println(status); } } job.addListener(new GramJobListenerImpl()); job.addListener(new GramJobListenerImpl());
•// Submit the job to a GRAM resource manager// Submit the job to a GRAM resource managerjob.request(“hot.mcs.anl.gov”); job.request(“hot.mcs.anl.gov”); // default IANA port 2119// default IANA port 2119
•//Cancel the job, if need be.//Cancel the job, if need be.job.cancel()job.cancel()
•// Check whether you can submit a job to a particular // Check whether you can submit a job to a particular gatekeeper.gatekeeper.
Gram.ping( proxy, “hot.mcs.anl.gov”);Gram.ping( proxy, “hot.mcs.anl.gov”);
•// Create a job// Create a job
GramJob job = new GramJob(proxy, rsl.toRSL());GramJob job = new GramJob(proxy, rsl.toRSL());
•// Add a status change listener// Add a status change listenerclass GramJobListenerImpl class GramJobListenerImpl implements GramJobListener {implements GramJobListener { public void statusChanged(GramJob job) { public void statusChanged(GramJob job) { String status = job.getStatusAsString(); String status = job.getStatusAsString(); System.out.println(status); System.out.println(status); } } job.addListener(new GramJobListenerImpl()); job.addListener(new GramJobListenerImpl());
•// Submit the job to a GRAM resource manager// Submit the job to a GRAM resource managerjob.request(“hot.mcs.anl.gov”); job.request(“hot.mcs.anl.gov”); // default IANA port 2119// default IANA port 2119
•//Cancel the job, if need be.//Cancel the job, if need be.job.cancel()job.cancel()
Identity id = cog-run (“-h hot.mcs.anl.gov –e nbody”);Identity id = cog-run (“-h hot.mcs.anl.gov –e nbody”);Identity id = cog-run (“-h hot.mcs.anl.gov –e nbody”);Identity id = cog-run (“-h hot.mcs.anl.gov –e nbody”);
Scientific workflows <project> <include file="cogkit.xml"/> <execute executable="/bin/climate" host="hot.mcs.anl.gov" provider="GT4"/> <echo message="Job completed"/> </project>
Lessen we seem to learn: Kepler and Taverna complex
Education Tutorial and slide material available for Globus
They contain a portion We found that for beginners the entry curve is steep CoG Kit entry curve is relatively low
Authentication, job submission, file transfer (ssh like …) Used successfully in REU and SULI projects (undergrads)
Viz/GUIs gets students interested Educational dichometry:
we do want to use the Grid but do not want or have the time to learn about it
References Globus
http://www.globus.org CoG Kits
http://www.cogkit.org Portals
http://www.ogce.org Papers
http://www.mcs.anl.gov/~gregor The Grid-Idea and Its Evolution, Gregor von Laszewski, accepted for
publication in the Journal of Information Technology, http://www.mcs.anl.gov/~gregor/papers/vonLaszewski-grid-idea.pdf
Biography Gregor von Laszewski is a Scientist at Argonne National Laboratory and a fellow of the Computation Institute at University
of Chicago. He received a Masters Degree in 1990 from the University of Bonn, Germany, and a Ph.D. in 1996 from Syracuse University in computer science. He is involved in Grid computing since the term was coined. Current research interests are in the areas of Grid computing, Grid workflows, and Grid user interfaces. He is the principal investigator of the Java Commodity Grid Kit which provides a basis for manyGrid related projects.
Why do we need the Grid today? Changing Nature of Work
IT must adapt to this new realityIT must adapt to this new reality
Collaborative and DynamicCollaborative and Dynamic
Project focused, globally distributed teams, spanning
organizations within and beyond company boundaries
Project focused, globally distributed teams, spanning
organizations within and beyond company boundaries
Distributed and HeterogeneousDistributed and Heterogeneous
Each team member/group brings own data, compute, & other resources into the project
Each team member/group brings own data, compute, & other resources into the project
Data & Computation Intensive
Data & Computation Intensive
Access to computing and data resources must be coordinated
across the collaboration
Access to computing and data resources must be coordinated
across the collaboration
Concurrent Innovation Cycles
Concurrent Innovation Cycles
Resources must be available to projects with strong QoS, & also
reflect enterprise-wide biz priorities
Resources must be available to projects with strong QoS, & also
reflect enterprise-wide biz priorities
Approach: Bridging the Application-Resource Gap
IBM
IBM
Uniform interfaces,security mechanisms,Web service transport,
monitoring
Computers StorageSpecialized resource
UserApplication
UserApplication
IBM
IBM
GRAM GridFTPHost EnvUser Svc
DAIS
Database
ToolTool
Workflow
Credent.
Host EnvUser Svc
Registry
UserApplication
WSDL, SOAP, WS-Security
CustomServices
WS-A, WSRF, WS-Notification
CustomWSRF
Services
GT4WSRF Web
Services Reg
istr
y&
Adm
in
GT
4 C
onta
iner
(e.g
., A
pach
e A
xis)
GT4 & Web Services
User Applications
GT4 Services Include …
Data GridFTP: file access & movement Reliable File Transfer Replica Location Service Data Access & Integration: database access
Computation GRAM: reliable job submission Workspace: virtual machine deployment
Security Credential repository, authorization, …
… & many others …
Grid Communication Protocol
Service Description
Service
Workflow
Service R
egistry
Secu
rity
Metad
ata Man
agem
ent
Reso
urce M
anag
emen
t
Functions Management
ID R
esolu
tion
Transport
Used to Create Powerful Systems:E.g., Cancer Bioinformatics Grid
Sch
ema M
anag
emen
t GSI
CAS
myProxy
Globus
OGSA-DAIGlobusGRAM
Globus Toolkit
GlobusBPEL
Mobius
caCORE
Slide credit: Peter Covitz, National Institutes of Health
Spans 60 NIH cancer centers across the U.S.
A Stateful Odyssey
A simple goal Web Services conventions for manipulating state
A hopeful departure OGSI: Open Grid Services Infrastructure
Some detours en route WS-RF: WS Resource Framework WS-Transfer and friends
Home at last? WS-ResourceTransfer, WS-Eventing, etc.
“Tell of the storm-tossed man, O Muse, who wandered long …” (Homer)
“And the end of all our exploring/Will be to arrive where we started/And know the place for the first time” (Elliot)
Stateful Odyssey: Practical Implications GT4 supports WSRF today
Mechanisms have proved incredibly useful in many different contexts
A large user community
We will incorporate support for: … final WSRF/WS-Notification specs … WS-RT & friends (when specs mature) If/when justified based on user demand
We will ensure backward compatibility Via a single service with multiple interfaces
Other Standards
Data GridFTP Data Access & Integration (DAIS) Replica location (in progress)
Security WS-Security, SAML — included in GT4 XACML — included in GT4 SAML-2 — awaiting contribution of code
Job submission JSDL – alpha implementation available BES – when BES specification completed
A Production Grid
The TeraGrid“The world’s largest collection of supercomputers”Slides courtesy of Jeffrey Gardner
& Charlie Catllet
TeraGrid: A High Level View
Grid Software and ENV Deployment
CTSS
Authorization, Accounting and Authentication
TG Allocation and Accounting
Grid Monitoring and Information
Systems
MDS4 & Inca
User & Facilities Support
Help desk/Portal and ASTA
TeraGrid
Allocation& Accounting
TeraGrid Allocation
Researchers request “allocation of resource” through formal process Process works similarly as that for submitting a NSF grant
proposal There are eligibility requirements
US faculty member or researcher for an non-profit organization Principle Investigators submits CV More…
Description of research, requirements etc. Proposal is peer reviewed by allocation committees:
DAC: Development Allocation Committee MRAC: Medium Resource Allocation Committee LRAC: Large Resource Allocation Committee
Authentication, Authorization & Accounting TG Authentication & Authorization is automatic
User accounts are created when allocation is granted Resources can be accessed through:
ssh: via password, ssh keys Grid access: via GSI mechanism (grid-mapfile, proxies…)
Accounts created across TG sites users in allocation
Accounting system is oriented towards TG Allocation Service Units (ASU) Accounting system is well defined and monitored closely Each TG sites is responsible for its own accounting
TeraGridMonitoring and Validation
TeraGrid and MDS4
Information providers: Collect information from various sources
Local batch system; Torque, PBS Cluster monitoring; ganglia, Clumon… Spits out XML in a standard schema (attribute value
pairs)
Information is collected into local Index service Global TG wide Index collector with WebMDS
Site1
GT4 Container
WS-GRAM
MDS4Index
Clumon
PBS
Site2
GT4 Container
WS-GRAM
MDS4Index
Ganglia
Torque
TG WideIndex
WebMDS
BrowserBrowserApplication
Application
Inca: TeraGrid Monitoring…
Inca is a framework for the automated testing, benchmarking and monitoring of Grid resource Periodic scheduling of information gathering Collects and archives site status information Site validation & verification
Checks site services & deployment Checks software stack & environment
Inca can also site performance
measurements
TeraGridGrid Middleware & Software Environment
The TeraGrid Environment SoftEnv: all software on TG can be accessed via
keys defined in $HOME/.soft SoftEnv system is user configurable Environment can also be accessed at run time for
WS GRAM jobs
You will be interacting with SoftEnv during the exercises later todayYou will be interacting with SoftEnv during the exercises later today
TeraGrid Software: CTSS
CTSS: Coordinated TeraGrid Software Service A suite of software packages that includes globus toolkit, condor-
g, myproxy, openssh… Installed at every TG site
TeraGrid User & Facility Support The TeraGrid Help desk help@teragrid.org
Central location for user support Routing of trouble tickets
TeraGrid portal: User’s view of TG
Resources Allocations…
Access to Docs!
TeraGrid’s ASTA Program
Advanced Support for TeraGrid Application Help application scientists with TG resources Associates one or more TG staff with application
scientists Sustained effort A minimum of 25% FTE
GoalMaximize effectiveness
of application software &
TeraGrid resources
Topics Not Covered
Managed Storage Grid Scheduling More
Managing Storage Problems:
No real good way to control the movement of files into and out of site
Data is staged by fork processes! Anyone with access to the site can submit such a request and
swamp the server There is also no space allocation control
A grid user can dump files of any size on a resource If users do not cleanup sys, admin have to intervene
These can easily overwhelm a resource
Managing Storage
A Solution: SRM (Storage Resource Manager) Grid enabled interface to put data on a site
Provides scheduling of data transfer requests Provides reservation of storage space
Technologies in the OSG pipeline dCache/SRM (disk cache with SRM)
Provided by DESY & FNAL SE(s) available to OSG as a service from the USCMS VO
DRM (Disk Resource Manager) Provided by LBL Can be added on top of a normal UNIX file system
$> globus-url-copy srm://ufdcache.phys.ufl.edu/cms/foo.rfz \ gsiftp://cit.caltech.edu/data/bar.rfz
Grid Scheduling
The problem: With job submission this still happens!
Grid Site B
Grid Site AUser InterfaceVDT Client
?
Grid Site X
Why do I have to do this by hand? Why do I have to do this by hand? @?>#^%$@#
Grid Scheduling Possible Solutions
Sphinx (GriPhyN, UF) Work flow based dynamic planning (late binding) Policy based scheduling More details ask Laukik
Pegasus (GriPhyN, ISI/UC) DAGman based planner and Grid scheduling (early binding) More details in Work Flow
Resource Broker (LCG) Match maker based Grid scheduling Employed by application running on LCG Grid resources
Much Much More is Needed Continue the hardening of middleware and other software
components Continue the process of federating with other Grids
OSG with TeraGrid OSG with LHC/EGEE, NordiGrid…
Continue to synchronize the Monitoring and Information Service Infrastructure
Improve documentation
Conclude with a simple example1. Log on to a User Interface; 2. Get your grid proxy “logon to the grid” grid-proxy-init3. Check OSG MIS clients
• To get list of available sites: depends on your VO affiliation• To discover site specific information needed by your job ie,
Available services: hostname, port numbers Tactical storage location: $app, $data, $tmp, $wntmp
4. Install your application bins at selected sites5. Submit your jobs to selected sites via condor-G6. Check OSG MIS clients to see if jobs have completed7. Do something like this: If [ 0 ] then echo “Have a coffee (beer, margarita…)” else echo “its going to be a long night” fi
To learn more:
The Open Science Grid top level page http://www.opensciencegrid.org
The TeraGrid top level page http://www.teragrid.org
The TeraGrid portal https://portal.teragrid.org/gridsphere/gridsphere
The globus website http://www.globus.org
The iVDGL website http://www.ivdgl.org
The GriPhyN website http://www.griphyn.org
Data Transfers @ the TG Gridftp is available at all sites:
Provides: GSI on control and data channels Parallel streams third party transfers Stripped
Each TG sites has 1 to several dedicated GridFTP enabled servers
TeraGrida sites are equiped with various gridftp clients globus-url-copy
Standard globus gridftp clients (see lectures) uberftp
interactive GridFTP client. supports GSI authentication, parallel file transfers. tgcp
wrapper for globus-url-copy (optimized tcp buffer sizes…parallel streams…) Interfaced with RFT (Reliable Transfer Service), performs third party transfers make sure
files gets to destination see lectures?
How can Markup languages help Pro:
Standardization Language neutral
Some languages have good support through classes Framework neutral (mostly) Hip/Fashionable
Con: Mostly not human readable Binary data is not easy to encode Parsing large documents need some thought
Pull parser vs. document parser Programming can be tedious Is there really a standard?
Standardization Language Independence User unfriendliness
Service Description
Information services Job submission
Configuration
YAML vs XML http://www.kuro5hin.org/story/2004/10/29/14225/062
YAML vs XML <user id=”gregor" computer=”suny.mcs.anl.gov"> <firstname>Gregori</firstname> <lastname>von Laszewski</lastname> <department>Argonne</department> <phone>630- 252 2000</phonel>
<addresses> <address>gregor@mcs.anl.gov</address> <address> laszewski@gmail.com</address> </addresses> </user>
user:
id: gregor
computer : sunny.mcs.anl.gov
firstname: Gregor
lastname: von LAszewski
phone: 630 252 2000
addresses:
- address: gregor@mcs.anl.gov
- address: laszewski@gmail.com
YAML YAML is a machine parsable data serialization format
documents are very readable by humans. interacts well with scripting languages (Perl, Ruby, Python, …). uses host languages' native data structures. has a consistent information model. enables stream-based processing. is expressive and extensible. is easy to implement.
Features Structure is shown through indentation Sequence items are denoted by a dash Key value pairs within a map are separated by a colon.
YAMLkern: ostype : Darwin osrelease : 8.7.1 osrevision : 199506 version : Darwin Kernel Version 8.7.1: Wed Jun 7 16:19:56 … maxproc : 532 maxfiles : 12288 argmax : 262144 securelevel : 1 hostname : sunny.mcs.anl.gov hostid : 0 clockrate:
hz : 100tick : 10000 profhz : 100 stathz : 100
posix1version : 200112 ngroups : 16…
Conventions sysctl -a on Mac OSXkern.ostype = Darwinkern.osrelease = 8.7.1kern.osrevision = 199506kern.version = Darwin Kernel Version 8.7.1: Wed Jun 7 16:19:56 … kern.maxproc = 532kern.maxfiles = 12288kern.argmax = 262144kern.securelevel = 1kern.hostname = lapi-56.mcs.anl.govkern.hostid = 0kern.clockrate: hz = 100, tick = 10000, profhz = 100, stathz = 100kern.posix1version = 200112kern.ngroups = 16…
LDIF dn: cn=The Postmaster,dc=example,dc=com objectClass: organizationalRole cn: The Postmaster ….
Unique identifier Definition of object classes
http://tools.ietf.org/html/rfc2849
LDIFdn:cn=Barbara Jensen, ou=Product Development, dc=airius, dc=comobjectclass:topobjectclass:personobjectclass:organizationalPersoncn:Barbara Jensencn:Barbara J Jensencn:Babs Jensensn:Jensenuid:bjensentelephonenumber:+1 408 555 1212description:Babs is a big sailing fan, and travels extensively in sea rch of perfect sailing conditions.title:Product Manager, Rod and Reel Division
LDIFkern.ostype = Darwinkern.osrelease = 8.7.1kern.osrevision = 199506kern.version = Darwin Kernel Version 8.7.1: Wed Jun 7 16:19:56 … kern.maxproc = 532kern.maxfiles = 12288kern.argmax = 262144kern.securelevel = 1kern.hostname = lapi-56.mcs.anl.govkern.hostid = 0kern.clockrate: hz = 100, tick = 10000, profhz = 100, stathz = 100kern.posix1version = 200112kern.ngroups = 16…
LDIFkern.ostype = Darwinkern.osrelease = 8.7.1kern.osrevision = 199506kern.version = Darwin Kernel Version 8.7.1: Wed Jun 7 16:19:56 … kern.maxproc = 532kern.maxfiles = 12288kern.argmax = 262144kern.securelevel = 1kern.hostname = lapi-56.mcs.anl.govkern.hostid = 0kern.clockrate: hz = 100, tick = 10000, profhz = 100, stathz = 100kern.posix1version = 200112kern.ngroups = 16…
JSON vs XMLJSON:
{"menu": { "id": "file", "value": "File:", "popup": { "menuitem": [ {"value": "New", "onclick": "CreateNewDoc()"}, {"value": "Open", "onclick": "OpenDoc()"}, {"value": "Close", "onclick": "CloseDoc()"} ] }}}
XML:
<menu id="file" value="File" > <popup> <menuitem value="New" onclick="CreateNewDoc()" /> <menuitem value="Open" onclick="OpenDoc()" /> <menuitem value="Close" onclick="CloseDoc()" /> </popup></menu>
Some “simple” Examples
$ wsrf-query -s https://127.0.0.1:8443/wsrf/services/DefaultIndexService \"count(//*[local-name()='Entry'])”
$ wsrf-query -s https://127.0.0.1:8443/wsrf/services/DefaultIndexService \ "number(//*[local-name()='GLUECE']/glue:ComputingElement/glue:State/@glue:FreeCPUs)=0”
$ wsrf-query -s http://localhost:8080/wsrf/services/ContainerRegistryService \ "/*/*/*/*[local-name()='Address']"
THE END
Outline Introduction to Grid Computing Basic networking, security and other definitions Very basic web services Hardware components and Grids Introduction to Grid middleware components
Security Job management Data management Information