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