Notes for Computer Networks
Published:
Chapter 1
Multiplexing
- FDM: the frequency spectrum is divided into frequency bands for individual signals.
- Wavelength Division Multiplexing is just FDM at very high frequencies
- TDM: the users take turns to use the entire bandwidth for a little burst of time.
- CDMA (Code Division Multiple Access)
Switching
- circuit switching
- connection-oriented
- a complete path established prior to the call, which lasts for the duration
- message switching
- packet switching
- connection-less
- data is divided into packets
- users share network resources (link, router) with store-and-forward approach.
- route chosen on packet-by-packet basis
- statistical multiplexing: resource are allocated and shared on demand.
- Virtual circuit:
- All packets associated with a session follow the same path
- Route is chosen at start of session
- Packets are labeled with a VC# designating the route
Four sources of packet delay
- processing
- queuing
- transmission delay
- propagation delay
The network core
- mesh of interconnected routers
- how is data transferred through net?
- circuit switching
- packet switching
Network of Networks
- ISP: Internet Service Provider
- Tier-1 ISP
- can reach every other network on the Internet without purchasing IP transit or paying settlements
- treat each other as equals
- national/international coverage (e.g. ChinaGBN, ChinaNet)
- Tier-2 ISP
- smaller (often) regional ISPs, connect to one or more Tier-1 ISPs, possibly other Tier-2 ISPs
- Tier-3 ISP
- last hop (“access”) network (closest to end systems)
Chapter 2
Hybrid of client-server and P2P
- Skype
- voice-over-IP P2P application
- centralized server: finding address of remote party
- client-client connection: direct (not through server)
- Instant messaging
- chatting between two users is P2P
- centralized service: client presence detection/location
What transport services dies an app need?
- data loss
- delay
- throughput: some apps (e.g., multimedia) require minimum amount of throughput to be “effective”; other apps (“elastic apps”) make use of whatever throughput they get.
- security
TCP service
- connection-oriented
- reliable transport
- flow control: sender won’t overwhelm receiver
- congestion control: throttle sender when network overloaded
- does not provide: timing, minimum throughput guarantees, security
Identifying processes
process identifier = IP address + port numbers
Domain Name System
- map between IP addresses and name.
- www.sjtu.edu.cn –> <IP_ADDRESS>
- distributed database implemented in hierarchy of many name servers
- TLDs (Top-Level Domains)
- 22+ generic TLDs
- about 250 country code TLDs
- TLDs (Top-Level Domains)
- application-layer protocol host, routers, name servers to communicate to resolve names (address/name translation)
- UDP on port 53
- 13 root name services worldwide
- Contacted by local name server that can not resolve name
- contacts authoritative name server if name mapping not known
- gets mapping
- returns mapping to local name server
- Contacted by local name server that can not resolve name
- When host makes DNS query, query is sent to its local DNS server
- acts as proxy, forwards query into hierarchy
DNS protocol, messages
- DNS protocol: query and reply messages, both with same message format
- identification: 16 bit # for query, reply to query uses same #
DNS servers
- Three classes:
- root DNS servers
- top-level domain DNS servers: These servers are responsible for top-level domains such as com, org, net, edu, and gov, and all of the country top-level domains such as uk, fr, ca, and jp.
- authoritative DNS servers
- There is another important type of DNS server called the local DNS server. A local DNS server does not strictly belong to the hierarchy of servers but is nevertheless central to the DNS architecture
HTTP（HyperText Transfer Protocol）
- Uses TCP
- client initiates TCP connection (creates socket) to server, port 80
- server accepts TCP connection from client
- HTTP messages exchanged between browser (HTTP client) and Web server (HTTP server)
- TCP connection closed
- HTTP is “stateless”
- server maintains no information about past client requests
- http request message general format
- method types
- HTTP/1.0
- GET
- POST
- HEAD
- HTTP/1.1
- GET, POST, HEAD
- PUT
- DELETE
- HTTP/1.0
HTTP response status codes
- Every request gets a response consisting of a status line, and possibly additional information.
- The status line contains a three-digit status code telling whether the request was satisfied, and if not, why not.
Cookies
- four components:
- cookie header line of HTTP response message
- cookie header line in HTTP request message
- cookie file kept on user’s host, managed by user’s browser
- back-end database at Web site
HTTP Performance
- Round Trip Time (RTT): time for a small packet to travel from client to server and back
- Page Load Time (PLT):
- One RTT to initiate TCP connection
- one RTT for HTTP request and first few bytes of HTTP response to return
- file transmission time
- total = 2 * RTT + transmission time
Electronic Mail
- mail servers
- mailbox: contains incoming messages for users
- message queue: contains outgoing messages to be sent
- SMTP protocol: between mail servers to send emails messages
- duplex TCP connection at port 25
- client: sending mail server
- server: receiving mail server
- mail access protocol
- POP:
- download and delete
- stateless across sessions
- IMAP:
- keep all messages at server
- keeps user state across sessions
- http: gmail etc
- POP:
CDN: Content delivery network
- Replicate Web pages on a bunch of servers
- Efficient distribution of popular content
- Faster delivery for clients
MIME
- Multipurpose Internet Mail Extensions
- MIME: to continue to use the RFC 822 format, but to add structure to the message body and define encoding rules for non-ASCII messages.
P2P
- Distributed Hash Table
- The distributed index Database has (key, value) pairs;
- key: content keywords
- value: IP address of the hosts with the content
- Assign integer identifier to each peer:
- ID(peer) = hash(IP, port)
- each peer only aware of immediate successor clockwise
- How to store (key, value) pairs in peers?
- Rule: store (key, value) pair to the peer that has the closestID.
- Convention: closest is the immediate successor of the key.
- The distributed index Database has (key, value) pairs;
Distributed Hash Table
both the number of neighbors per peer as well as the number of messages per query is O(log N), where N is the number of peers.
Socket
- Socket is locally identified with a port number
- Client needs to know server IP address and socket port number.
- API:
- BIND: associate a local address (port) with a asocket
- LISTEN: announce willingness to accept connections
Chapter 3
TCP and UDP
- TCP
- Flow control matches sender to receiver
- Congestion control matches sender to network
Ports
- Servers often bind to “well-known ports”
- FTP (20/21), SMTP (25), POP3 (110), IMAP (143), http (80), https(443).
Connection-oriented demux: Threaded Web Server
- TCP socket identified by 4-tuple:
(source IP address, source port number, dest IP address, dest port number)
Connectionless demux
- UDP socket identified by two-tuple:
(dest IP address, dest port number)
Why UDP?
- no connection establishment (which can add delay)
- no retransmission (which can add delay)
- simple: no connection state at sender, receiver
- small segment header: 8 bytes
- no flow control and congestion control: UDP can blast away as fast as desired
- Examples:
- short message interaction apps: DNS, SNMP, PRC
- loss tolerant and delay sensitive: ipPhone, SKYPE
Error detection code (EDC) and retransmission
- Parity checking
- single bit parity
- two dimensional bit parity
- Checksum: used in Internet (IP, TCP, UDP), but it is weak
- CRC: cyclic redundancy check
- Cyclic Redundancy Check used in link layer can detect all burst errors less than r+1 bits
- Four International Standards Generator Polynomials
- The power of CRC:
- all single-bit errors will be detected
- All two isolated single-bit errors will be detected
- By making (x + 1) a factor of G(x), all errors consisting of an odd number of inverted bits will be detected
- all burst errors of length <= r will be detected
- can be constructed in hardware
- CRCs are widely used on links (Ethernet, ADSL, Cable)
Forwarding Error Correction
- Hamming Code
- can only correct one bit error
- used when the error rate is low
- Convolutional codes and LDPC heavily used in wireless data link layer
Detection vs Correction
- Forward Error Correction:
- when errors are expected
- or when no time for transmission
- Error Detection and Retransmission
- more efficient when errors are not expected
- burst errors when they do occur
Reliable Data Transfer
- RDT 1.0:
- underlying channel perfectly reliable (no error control)
- receiver has enough buffer and CPU power (no flow control)
- RDT 2.0: channel with errors
- underlying channel may flip bits in packet (no lost)
- checksum to detect bit errors
- receiver feedback: control msgs (ACK, NAK)
- sender retransmits pkt on receipt of NAK
- FLAWS:
- if ACK/NAK corrupted, sender doesn’t know what happened at receiver
- possible duplicate pkt with retransmission
- Handling duplicates:
- sender retransmits current pkt if ACK/NAK garbled
- sender adds sequence number to each pkt
- receiver discards duplicate pkt
- RDT 2.1： receiver handles garbled ACK/NAKs
- RDT 2.2: a NAK-free protocol
- instead of NAK, receiver sends ACK for last pkt received OK, receiver must explicitlyinclude seq # of pkt being ACKed
- duplicate ACK at sender results in same action as NAK: retransmit current pkt
- RDT 3.0: channels with errors and loss
- sender waits “reasonable” amount of time for ACK
- requires countdown timer
- to handle duplicate pkt, receiver must specify seq # of pkt being ACKed
Selective Repeat vs Go-Back-N
- Go-back-N: timer for oldest in-flight pkt
- cumulative ACK
- retransmit pkt k and all higher seq# pkts in window when timeout(k)
- Selective Repeat
- individual ACK
- sender timer for each unACKed pkt
- sender only resends pkts for which ACK not received
Window Overlay Problem
- To avoid overlapping new receiving window with the original window, the maximum window size should satisfy:
sending window + receiving window <= (MAX_SEQ + 1)
TCP overview
- end-to-end: no support for multicasting or broadcasting
- reliable byte stream:
- no “message boundaries”
- hybrid of GBN and SR
- pipelined segments
- cumulative and piggyback acks
- single retransmission timer
- retransmissions are triggered by
- timeout events
- 3 duplicate acks before timer expires: fast retransmit
- only retransmit one segment
- full duplex
- sequence number: byte stream “number” of first byte in segment’s data
- TCP checksum:
- TCP checksum checks the header, the data, and a pseudo header.
- The pseudo-header helps detect mis-delivered packets.
- It also violates the protocol hierarchy since the IP addresses in it belong to the IP layer, not to the TCP layer.
TCP timer management
- Problem: How do we determine the best timeout value for retransmitting segments in the face of a large standard deviation of round-trip delays?
- Solution: uses dynamic algorithm that constantly adjusts the timeout interval, based on continuous measurements of network performance.
TCP flow control
- announcing window size:the maximum number of bytes that may be sent and received.
- zero window size: sender stop sending. Two exceptions:
- urgent data
- 1-byte request for reannounce the window size.
TCP congestion control
Congestion can be caused by:
- data in burst (app and transport layer)
- lack of capacity/bandwidth (physical layer)
- insufficient memory of routers (network layer)
- slow processors of routers (network layer)
Congestion Prevention Policies in Open Loop Systems
To achieve congestion control, select appropriate policies at various levels: data link, network, and transport layer.
- strategy:
- predict when congestion is about to happen
- reduce rate early
- two approaches:
- host-centric: TCP congestion control
- Router-centric: warning bit, choke packet, load shedding
TCP congestion control
- Sender uses packet loss as the network congestion signal
- TCP assume that lost packets are caused by congestion, not by links.
- TCP use a Congestion Window (CongWin)next to the window granted by the receiver. The actual window size is the minimum of the two.
- Algorithm:
- When CongWin is below Threshold, sender in slow-start phase, window grows exponentially.
- When CongWin is above Threshold, sender is in congestion-avoidance phase, window grows linearly.
- When a triple duplicate ACK occurs, Threshold and CongWin set to CongWin/2.
- When timeout occurs, Threshold set to CongWin/2 and CongWin is set to 1 MSS.
TCP Additive Increase, Multiplicative Decrease (AIMD)
- additive increase: increase CongWin by 1 MSS every RTT until loss detected
- multiplicative decrease: cut CongWin in half after loss
When should the slow start (exponential increase) end?
- If there is a loss event:
- sets the value of congestion window to 1
- sets the “slow start threshold” to cwnd/2
- when the value of cwnd equals ssthresh, slow start ends and TCP transitions into congestion avoidance mode.
when should congestion avoidance’s linear increase (of 1 MSS per RTT) end?
- a timeout occurs
- The value of cwnd is set to 1 MSS, and the value of ssthresh is updated to half the value of cwnd
- a triple duplicate ACK event
- TCP halves the value of cwnd
- the value of ssthresh to be half the value of cwnd
TCP throughput
- Under assumptions, Because TCP’s throughput (that is, rate) increases linearly between the two extreme values, we have:
average throughput = 0.75 * W / RTT - the throughput of a TCP connection as a function of the loss rate (L), the round-trip time (RTT), and the maximum segment size (MSS):
TCP fairness
- A congestion-control mechanism is said to be fair if the average transmission rate of each connection is approximately R/K; that is, each connection gets an equal share of the link bandwidth.
Chapter 4
Network Layer Function:
- glue/interconnect lower-level networks together: allow packets to be sent between any pair of hosts
- network layer provides either host-to-host connectionless service or host-to-host connection service, but not both.
- connection service => virtual circuit (VC) networks
- connectionless service => datagram networks
- network-layer connection service is implemented in the routers in the network core as well as in the end systems
- Internet is a datagram network.
Router Functions:
- routing
- forwarding/switching
- congestion control: drop packets, update routing table
Implementation
- Router Forwarding Plane are typically implemented in hardware.
- ROuter Control Plane are typically implemented in software.
Virtual Circuit
- VC consists of:
- path from source to destination
- VC numbers, one number for each link along the path
- entries in routers along path
- Packet carries VC number rather than destination address as the index of forwarding
- VC number can be changed on each link
- Routers maintain connection state information
Why not keep the same VC number?
- replacing the number from link to link reduces the length of the VC field in the packet header.
- VC setup is considerably simplified by permitting a different VC number at each link along the path of the VC
Router (four parts)
- input port
- output port
- routing processor
- switching fabric
Input port function
- physical layer
- bit-level reception
- data link layer
- processing (protocol, decapsulation)
- network layer
- lookup, forwarding, queuing
Three types of switching
- memory: The simplest, earliest routers were traditional computers, with switching between input and output ports being done under direct control of the CPU (routing processor). An input port with an arriving packet first signaled the routing processor via an interrupt. The packet was then copied from the input port into processor memory. The routing processor then extracted the destination address from the header, looked up the appropriate output port in the forwarding table, and copied the packet to the output port’s buffers.
- bus: If multiple packets arrive to the router at the same time, each at a different input port, all but one must wait since only one packet can cross the bus at a time.
- interconnection network: A crossbar switch is an interconnection network consisting of 2N buses that connect N input ports to N output ports. If two packets from two different input ports are destined to the same output port, then one will have to wait at the input, since only one packet can be sent over any given bus at a time.
Output ports
- switch fabric -> queuing (buffer management) -> data link processing (protocol, decapsulation) ->line termination
Input port queuing
- fabric slower than input ports combined -> queuing may occur at input queues
- head-of-the-Line (HOL) blocking: queued datagram at front of queue prevents others in queue from moving forward
Output Port Queuing
- buffering when arrival rate via switch exceeds output line speed
Buffer design
- how much buffer? rule of thumb
- RTT; round-trip time; C: link capacity; N: number of TCP flows
- average buffer = RTT * C
- recent recommendation: with N flows, buffer equal to $RTT * C / \sqrt{N}$
Internet’s network layer
- IP protocol
- routing component: routing protocols compute the forwarding tables that are used to forward packets through the network
- a facility to report errors in datagrams and respond to requests for certain network-layer information: Internet Control Message Protocol (ICMP)
Datagram format
- protocol: This field is used only when an IP datagram reaches its final destination. The value of this field indicates the specific transport-layer protocol to which the data portion of this IP datagram should be passed. A value of 6 indicates that the data portion is passed to TCP, while a value of 17 indicates that the data is passed to UDP.
Header length
- IP header: 20 bytes
- TCP header: 20 bytes
MTU
The maximum amount of data that a link-layer frame can carry is called the maximum transmission unit (MTU).
IP fragmentation and reassembly
- Reassembling is done in end systems rather than routers.
- maximum transmission unit (MTU) of link layer puts a hard limit to the size of IP datagram
- the designers of IPv4 decided to put the job of datagram reassembly in the end systems rather than in network routers
- identification, flag, fragmentation field in the header
- in order for the destination host to be absolutely sure it has received the last fragment of the original datagram, the last fragment has a flag bit set to 0, whereas all the other fragments have this flag bit set to 1.
- At the destination, the payload of the datagram is passed to the transport layer only after the IP layer has fully reconstructed the original IP datagram. If one or more of the fragments does not arrive at the destination, the incomplete datagram is discarded and not passed to the transport layer
- Example:
A datagram of 4,000 bytes (20 bytes of IP header plus 3,980 bytes of IP payload) arrives at a router and must be forwarded to a link with an MTU of 1,500 bytes.
IP header options
- security: specifies how secret the datagram is.
- strict source routing: gives the complete path to be followed
- loose source route: gives a list of routers not to be missed
- record route: makes each router append its IP address
- Timestamp: makes each router append its timestamp and address
IP address
- 32 bit identifier for interface of routers and hosts
- written in dotted decimal
- must be globally unique for globally access
- IP requires each host and router interface to have its own IP address. Thus, an IP address is technically associated with an interface, rather than with the host or router containing that interface.
Subneting
- IP network: all computers addressed with a common identical network id
- an IP network is a broadcasting network
- multiple IP networks are interconnected by routers or 3-layer switch (VLAN)
- Problem with large IP networks:
- different computers are administratively controlled by different entities
- broadcasting storm
-
solution: dividing an IP network into two or more networks is called subnetting
- What’s a subnet?
- device interfaces with same subnet part of IP address
- can physically reach each other without intervening routers
- subnet mask: <IP_ADDRESS>/24, indicates that the leftmost 24 bits of the 32-bit quantity define the subnet address.
Classless IP Addressing
- VLSM: variable length subnet mask
- IP address = subnet id + host id
- subnet mask: to indicate the subnet portion which is variable length
- a.b.c.d/x, where x is # bits in subnet portion of address
- 1 for subnet id bits, 0 for host id bits (e.g. <IP_ADDRESS>)
The Internet’s address assignment strategy: CIDR (Classless InterDomain Routing)
- problem: routing table explosion
- assign class C addresses in contiguous blocks of 256 addresses so that multiple entries in routing table can be aggregated into one (reduced)
- Contiguous blocks of IP addresses with common prefix and the whole range of that prefix could be aggregated into one route entry.
- Even if there is a hole in the blocks of IP addresses the common prefix could still be aggregated with another longer prefix for the hole.
IP broadcast address
When a host sends a datagram with destination address <IP_ADDRESS>, the message is delivered to all hosts on the same subnet. Routers optionally forward the message into neighboring subnets as well
DHCP: Dynamic Host Configuration Protocol
- For obtaining a host address
- Four steps:
- DHCP server discovery: the DHCP client creates an IP datagram containing its DHCP discover message along with the broadcast destination IP address of <IP_ADDRESS> and a “this host” source IP address of <IP_ADDRESS>.
- DHCP server offer(s): A DHCP server receiving a DHCP discover message responds to the client with a DHCP offer message that is broadcast to all nodes on the subnet, again using the IP broadcast address of <IP_ADDRESS>
- DHCP request: The newly arriving client will choose from among one or more server offers and respond to its selected offer with a DHCP request message,
- DHCP ACK: The server responds to the DHCP request message with a DHCP ACK message, confirming the requested parameters.
NAT: Network Address Translation
- Motivation: hosts in LANs use private IP address and share one public IP address for internet access
- handle public IP address shortage
- can change address of devices in LAN without notifying outside world
- can change ISPs without changing addresses of devices in LANs
- devices inside not explicitly addressable, visible by outside world (a security plus)
- uses 16 bit port field
- The NAT-enabled router does not look like a router to the outside world. Instead the NAT router behaves to the outside world as a single device with a single IP address.
- NAT is controversial:
- violates independence layering principles
- violates end-to-end argument
- NAT traversals must be taken into account by app designers
- address shortage should instead be addressed by IPv6
NAT Traversal Problem
- Solution 1: statically configure NAT to forward incoming connection requests at given port to server
- Solution 2: Universal Plug and Play: With UPnP, an application running in a host can request a NAT mapping between its (private IP address, private port number) and the (public IP address, public port number) for some requested public port number. In summary, UPnP allows external hosts to initiate communication sessions to NATed hosts, using either TCP or UDP.
- Solution 3: relaying (used in Skype)
- NATed client establishes connection to relay
- External client connects to relay
- relay bridges packets between to connections
ICMP
- Internet Control Message Protocol
- ICMP is often considered part of IP but architecturally it lies just above IP, as ICMP messages are carried inside IP datagrams. That is, ICMP messages are carried as IP payload
- Note that ICMP messages are used not only for signaling error conditions.
IPv6
- initial motivation: 32 bit address space soon to be completely allocated
- additional motivation:
- header format helps speed processing/forwarding
- header changes to facilitate QoS
- IPv6 datagram format:
- fixed length 40 byte header
- extension header allowed
- IPv6 increases the size of the IP address from 32 to 128 bits
- The resulting 40-byte fixed-length header allows faster processing of the IP datagram
Comparison of IPv4 and IPv6
- IPv4: 20+ byte headers, 12 + 1 fields
- IPv6: 40 byte headers, 8 fields
Routing Algorithm classification
- global:
- all routers have complete topology and link cost information
- link state algorithm
- local:
- routers knows link costs to neighbours, exchange of info with neighbors
- distance vector algorithm
- static:
- routers change slowly over time
- dynamic:
- routers change more quickly
- periodic update
- in response to network topology and link costs changes
- Internet routing algorithms (such as RIP, OSPF, and BGP) are load-insensitive, as a link’s cost does not explicitly reflect its current (or recent past) level of congestion.
Routing algorithms
Link state routing (LSR):
- Each router learns the entire network topology through exchanging information with all other routers, and then calculate least cost path to the other routers.
- Dijkstra’s algorithm to build the sink tree
- The number of times the loop is executed is equal to the number of nodes in the network.
Distance Vector Routing / Bellman-Ford
- Each router maintains a table (i.e Distance Vector) with least cost/distance to every other routers.
Comparison between LSR and DVR
- message complexity:
- LSR: with n nodes, E links, O(nE) messages sent totally, O(n^2) complexity
- DVR: exchange between neighbors only, O(n) totally
- computation complexity:
- LSR: O(n^2) each node
- DVR: O(n) each node
- speed of convergence:
- LSR: 1 iteration, may have oscilliations
- DVR: n iterations
- good news travel fast
- count-to-infinity problem
- updating when:
- local link cost change
- LS/DV update message from others/neighbors
- periodically
- Neither algorithm is an obvious winner over the other; indeed, both algorithms are used in the Internet.
Hierarchical Routing
- Autonomous System (AS): aggregate routers into regions, correspond to an administrative domain. Assigned an unique 16/32 bit number
- intra-AS/interior gateway routing should find the least cost path as best as possible
- routers in same AS run same routing protocol
- routers in different AS can run different intra-AS routing protocol
- inter-AS/exterior gateway routing has to deal with a lot of politics. Routers do not automatically use the routes they find, but have to check manually whether it is allowed.
- Why different intra-AS, inter-AS routing?
- policy:
- inter-AS: admins want to have control over how its traffic routed, and who routes through its net. (untrusted)
- intra-AS: single admin, so no policy decisions needed (trusted)
- scale: hierarchical routing saves table size, reduced update traffic
- performance:
- intra-AS: can focus on performance
- inter-AS: policy may dominate performance
- policy:
Routing in the internet - Hierarchical
- most common intra-AS routing protocols
- RIP: Routing Information Protocol
- OSPF: Open Shortest Path First
- IGRP: Interior Gateway Routining Protocol
- most common inter-AS routing protocols
- BGP: Border Gateway Protocol
RIP (Routing Information Protocol)
- Distance Vector Algorithm
- DV advertisement exchanged among neighbors every 30 sec in UDP packets
- In RIP (and also in OSPF), costs are actually from source router to a destination subnet. RIP uses the term hop, which is the number of subnets traversed along the shortest path from source router to destination subnet, including the destination subnet.
- distance metric: # of hops, Limits networks to 15 hops (16 = inf to avoid count-to-infinity)
OSPF (Open Shortest Path Protocol)
- “open”: the routing protocol specification is publicly available
- OSPF is a link-state protocol that uses flooding of link-state information and a Dijkstra least-cost path algorithm
- OSPF advertisements disseminated to entireAS
- hierarchical OSPF in large domains
RIP and OSPF
- OSPF and its closely related cousin, IS-IS, are typically deployed in upper-tier ISPs
- RIP is deployed in lower-tier ISPs and enterprise networks
Hierarchical OSPF
- An OSPF autonomous system can be configured hierarchically into areas. Each area runs its own OSPF link-state routing algorithm, with each router in an area broadcasting its link state to all other routers in that area.
- two level hierarchy:
- local area: run OSPF
- backbone: area 0
- four kinds routers
- internal routers (IR)
- area border routers (ABR): Within each area, one or more area border routers are responsible for routing packets outside the area
- backbone routers (BaR): exactly one OSPF area in the AS is configured to be the backbone area. The primary role of the backbone area is to route traffic between the other areas in the AS
- boundary routers (BoR)
Border Gateway Protocol
- advertised prefix includes BGP attributes
- route = prefix + AS-path + Next-hop
- router may learn about multiple routes to some prefix. Router must select one from the routes.
- ordered selection rules (for good instead of best route):
- Local preferences (policy)
- Shortest AS-path
- Closet next hop router
- Additional criteria
Broadcast and multicast routing
broadcast routing:
- deliver packets from source to all other routers
- source duplication is inefficient
- in-network duplication can be more efficient with controlled duplicate transmission
- flooding: when node receives brdcst pckt, sends copies to all neighbors
- controlled flooding: node only brdcsts pkt if it hasn’t brdcst same packet before
- node keeps track of pckt IDs already brdcsted
- reverse path forwarding (RPF): only forward pckt if it arrived on shortest path between node and source
- spanning tree: no redundant packets received by any nodes
- nodes forward copies only along spanning tree
- Pro: makes excellent use of bandwidth
- Con: each router must have knowledge of some spanning tree
Multicast Routing
- goal: find a tree (or trees) connecting routers having local mcast group members
- source-based: different tree from each sender to rcvrs
- shared-tree: same tree used by all group members
- IP multicasting uses class D addresses
- Each class D address identifies a group of hosts.
- Groups are managed using IGMP (Internet Group Management Protocol)
- operates between a host and its directly attached router
- Network-layer multicast in the Internet consists of two complementary components: IGMP and multicast routing protocols.
- Intra-AS Multi-cast Routing Protocols
- Distance-Vector Multicast Routing Protocol (DVMRP) uses an RPF algorithm with pruning
- Protocol-Independent Multicast (PIM) routing protocol
- dense mode based on pruned RPF
- Sparse mode based on pruned spanning tree
- Inter-AS Multi-cast Routing Protocols
- extensions to BGP to allow it to carry routing information for other protocols, including multicast information
- MSDP(Multicast Source Discovery Protocol) to connect centers in PIM sparse mode
Chapter 5 The Data Link Layer
Checksum
- In the TCP and UDP protocols, the Internet checksum is computed over all fields (header and data fields included).
- In IP the checksum is computed over the IP header (since the UDP or TCP segment has its own checksum).
Data link layer
- Data link layer is the place in the protocol stack where software meets hardware (firmware)
- implemented in adapter (network interface card NID) in each host and routers
- Data-link layer has responsibility of transferring datagram from one node to physically adjacent node over a link (node-to-node job)
- Datagram transferred by different link protocols over multiple links from source to destination.
- point-to-point link protocols
- PPP
- HDLC
- broadcast link protocols
- Ethernet
- IEEE802.3
Data Link Layer Services
- framing: encapsulate datagram into frame, adding header, trailer
- reliable date transfer between adjacent nodes
- link access for shared medium
- Medium/Multiple Access Control (MAC)
- “MAC” addresses: used in frame headers to identify source, destination
Two point-to-point Data Link Protocols
- HDLC (High-Level Data Link Control):
- bit-oriented
- supports flow control and error control
- PPP (The Point-to-Point Protocol):
- Internet standard (RFC1661 1662 1663), is used in the Internet for a variety of purposes, including router-to-router traffic and home user-to-ISP traffic.
- byte-oriented
- PPP is a variant of HDLC without flow/error control, supporting multiple upper layer protocols
- PPP uses LCP to manage links and uses NCP to negotiate network-layer options
Ideal MAC Protocol
- for broadcast channel of rate R bps:
- efficient: when one node wants to transmit, it can send at rate R.
- fair: when M nodes want to transmit, each can send at average rate R/M
- fully decentralized:
- no special node to coordinate transmissions
- no synchronization of clocks, slots
- simple
Three broad classes of MAC protocols
- Channel Partitioning (static)
- divide channel into smaller “pieces” (TDM, FDM, CDM)
- allocate piece to node for exclusive use
- Random Access (dynamic)
- channel not divided, allow collisions
- “recover” from collisions
- Taking turns (dynamic)
- nodes take turns
- nodes with more to send can take longer turns
Random Access MAC Protocol
- random access:
- transmit at full channel data rate R When node has packet to send
- no priori coordination among nodes, possible collision
- random access MAC protocol specifies:
- how to detect collisions
- how to recover from collisions (e.g., via delayed retransmissions)
- Examples :
- ALOHA, slotted ALOHA
- CSMA, CSMA/CD, CSMA/CA
ALOHA
- Nodes transmit immediately whenever data is ready in pure ALOHA
- collision possible, retry after a random amount of time.
- frame sent at t0 collides with other frames sent in [t0-1,t0+1]
- Maximum efficiency of Pure ALOHA is 0.18
- Nodes transmit at the beginning of next slot whenever data is ready in slotted ALOHA
- Maximum efficiency of slottedALOHA is 0.36
- Problem: a node’s transmission decision is independent of other nodes’ activities
CSMA (Carrier Sense Multiple Access)
listen before transmit:
- If channel sensed idle: transmit entire frame
- p-persistent: transmit with probability p, and defer until next slot with probability 1-p.
- If channel sensed busy, defer transmission
- 1-persistent: keeping sensing and immediately start transmission when idle
- nonpersistent: wait a random period of time before trying again
Link-Layer Addressing
- Each adapter in LAN has 48 bit, permanent, globally unique MAC address
- MAC addresses are burned in NIC ROM
- ARP (Address Resolution Protocol) is used to translate IP address into MAC address
Ethernet efficiency
- Ethernet (bus) efficiency is better than ALOHA, but deteriorates as bit-rate and distance raise
- Ethernet or CSMA/CD is unsuitable for high speed and long distance networks.
Collision Region (CR) and Broadcast Region (BR)
- Use switch to reduce the collision region
- Use router to reduce the broadcasting region and connect with Internet.
Virtual LAN
- Use switch to reduce the broadcasting region with less overhead and more flexibility
- Multiple VLANs over single switch are different broadcast domains
- VLAN can span multiple switches from different physical location
- VLANs isolate broadcast domains, could only connected by routing
Chapter 6 Wireless and Mobile Networks
- The 802.11(WiFi) is the wireless version of 802.3 (Ethernet) , but much different in physical and data link layer.
- all use CSMA/CA for multiple access
- all have base-station and ad-hoc network versions
- 802.15: Bluetooth Architecture
- TDD(Time Division Duplexing) : The master in each piconet defines a series of 625 μsec time slots, with the master getting half the slots and the slaves sharing the other half.


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Press release
New careers guidance will see employers playing a larger role in careers advice in schools.
Pupils will be inspired and mentored by employers and business leaders to pursue ambitious careers under new guidance for schools published today by Skills and Enterprise Minister Matthew Hancock.
The Department for Education guidance will ensure schools provide pupils with experience of the world of work to give them the confidence and skills to fulfil their potential.
It will also highlight the importance of pupils gaining the skills that employers must look for when hiring, such as maths and science qualifications.
The statutory guidance states a school’s careers and inspiration guidance strategy should:
Skills and Enterprise Minister Matthew Hancock said:
To be successful in their future careers, young people need inspiration and mentoring as much as advice. This important guidance will encourage schools to help pupils develop high aspirations to realise their potential.
Employers and those themselves in careers they love are best placed to pass on knowledge and enthusiasm to young people. That is why we are encouraging schools to build links with employers to ensure pupils leave school with the skills employers need.
There is now no excuse for schools and colleges not to engage local employers or for employers not to support schools and colleges to help young people in the transition from education to employment.
Today’s announcement comes as part of a broader shift towards more rigorous careers guidance, as outlined in the government’s inspiration vision statement, published in September 2013. Other measures include:
The guidance includes examples of schools that already offer innovative careers guidance. Woodham Academy, in Newton Aycliffe, County Durham, invited employers working in the local business park to discuss careers with their pupils. This led to conferences between their 14-year-old pupils and local employers, and an Apprenticeship Challenge day involving speed-networking sessions with businesses and employers mentoring pupils.
The Charter School, an academy in Southwark, has formed mentoring and training links with PricewaterhouseCoopers, magazine publishers IPC Media and King’s College Hospital, among other local businesses. The academy’s teachers also work with mentors to highlight their pupils’ strengths and weaknesses, especially in maths, science and languages. All the pupils on the mentoring scheme have obtained a place at their chosen university or college, or found employment.
Brian Lightman, General Secretary of the Association of School and College Leaders, said:
The provision of high-quality careers guidance which enables young people to navigate through the bewildering range of opportunities in a fast-moving world remains an enormous challenge to schools.
We are therefore pleased that this more detailed statutory and non-statutory guidance has been prepared and includes case study examples of how schools are approaching the challenge.
Jake Hayman, founder of Future First, which sets up links mentoring and work experience networks with state schools, said:
We know that young people, particularly from less advantaged backgrounds, often don’t know about the huge range of opportunities that will be available to them in the future.
By exposing them to real-life role models, schools can motivate students, raise aspiration and help young people make informed choices whilst at school.
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Published: 10 April 2014


facial fit dimensions participants test respirator size study PCA RFTP bivariate face respirators RFTPs facepiece developed NIOSH Chen head maneuver panel nose QLFT U.S. different tests anthropometric Fig Health reported study, testing design group models panels total breadth completed length percentage users distribution factor Cells breadth, distributed final {border-style age maneuvers results males px;} small-to-medium subjects #ffffff;} Zhuang analysis cells change width Taiwan determined model principal Occupational Safety developing females head-and-face included male population study. "Moving Sciences component considered design. length, medium observed small using Hyg. National Occup RFTP, anthropometrics data development difference female filtering including respectively. sensitivity used "Bending characteristics groups individual required Chinese existing failed greater large level passed qualitative survey Cell However, Institute additional better current did influence new sizes target Environ Facial Head Head-and-face QNFT covered features general over" overall provide respirators. significant significantly solution threshold compared consisting exercised masks measured nasal panel. participants, passing px; sequence sufficiently test, up-and-down", variation years {font-family "Normal Cup Fit LANL Liner Nose Respirator Yang accordance candidates comparison components effect ethnic font-size frontal groups, half-mask identified interpupillary participant procedures quantitative representative representing stress subject users. values workers youths (.%), (Medium: .%, .%; American Biology Distribution Fold Large: Life Medicine QLFT, RFTPs. Science Table applied based breathing", comparable conducted coverage cycles dispersion double; ensure facepieces fit. geographical half key original panel, participants. population, prominent provided ranged ratio relation represent result root selected seven shows standard suggested taste up-and-down" use user "Talking" "Talking", < (.–.%; Ann China Click Department LINK Medical Overall, RFTPs, Thus, actual adopted bigonial border-color border-width born civilian consisted defined described design, distance, distinct distribution, exercise faceseal file. fit-tested following gender impact indicate indicated method narrow participants) performed petite population. protection shape similar smaller solid; specific successfully three-size weighted workplace {font-style {font-weight (.% (A) (B) (QLFT) (XLSX) (the .%) .–.% Administration Anatomy Anatomy: Bitragion Bitrex Comparison Health, Lee New PCs Percentage Principal Public QLFT. QNFT, RFTP. Research Wang Writing able accommodated aerosols allowed approach arc associated association available bold breathing calculated categorized cell chin circles comparison, completing concentrated contours counterparts courier; criteria cyan designed differences division eigenvectors em; engaged ethnical evaluate evaluation features. fell females) gender-specific groups. increased intended interpretation inward leakage literature maneuver. mask mean minimum number overlaid participating proportion pt;} related represented scale scatter second size, small-medium surveyed tested users, width) width, yellow young


LEPRECHAUN A film review by James Berardinelli Copyright 1993 James Berardinelli
Running Length: 1:31 Rated: R (Violence, gore, language)
Starring: Warwick Davis, Jennifer Aniston, Ken Olandt, Mark Holton, Robert Gorman Director: Mark Jones Producers: Jeffrey B. Mallian Screenplay: Mark Jones Music: Kevin Kiner Released by Trimark Pictures
When a leprechaun's treasure is stolen, he hunts down the thieves and kills them--at least that's the premise of LEPRECHAUN. In this case, one of the wee folk (Warwick Davis) has been relieved of a hundred gold coins. In an attempt to regain the lost treasure, he's captured by means of a four-leaf clover and trapped in a box. Ten years later, a girl (Jennifer Aniston) and her father move into the house where the leprechaun is trapped. Surprise of surprises, the leprechaun gets free and starts to kill and maim everyone in sight.
To begin with, this is a feeble premise for a movie.  I know that there are far more bad horror films than there are good ones, but this goes beyond simply being "bad". It's so unpleasant, in fact, that it isn't even worth a look as one of those popular "so bad they're good" films. It is legitimately unwatchable.
The plot is a mishmash of cliches. The dialogue was written with the brain- dead viewer in mind. Not only is it stilted and unrealistic, but writer Mark Jones seems determined to explain everything, no matter how obvious (and often ludicrous) it is. Of course, toward the end, the leprechaun has to be "killed" twice. This "sudden return" from the dead has, over the past few years, become one of the most-overused plot devices in Hollywood.
The actors seem perfectly suited for the stock characters they portray. Warwick Davis enjoys himself in an over-the-top performance, and Jennifer Aniston shows that, in different circumstances, she might be competent, but everyone else is horrible.
As is usual in pictures of this genre, there's a lot of blood, but, while some slasher flicks take pride in the art of presenting a murder, there's no style evident in LEPRECHAUN's various killings. The copious amounts of gore are more laughable than sickening. True to its unoriginal form, the leprechaun follows the recent trend of wisecracking whenever he injures or murders someone.
Then there's the intelligence of the characters to consider. Now I recognize that it's necessary for people occasionally to do stupid things in horror movies to advance the plot, but LEPRECHAUN thrives on far too many of these contrivances.  For example, if you suspect that a cat is rabid, would you stick your hand into a hole in a tree to try to get it out? Neither would I, but the characters of LEPRECHAUN approach the matter differently.
It's not worth wasting any more time on this review. LEPRECHAUN is a movie with virtually no redeeming qualities and even the most film- starved horror fan would do better watching HALLOWEEN for the umpteenth time than putting himself/herself through this torture. It's hard to believe that ninety-one minutes can seem this long.
Rating: 1.1 (F-, *)
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Configuration
Just like any other Akka module Akka HTTP is configured via Typesafe Config. Usually this means that you provide an application.conf which contains all the application-specific settings that differ from the default ones provided by the reference configuration files from the individual Akka modules.
These are the relevant default configuration values for the Akka HTTP modules.
akka-http-core
########################################
# akka-http-core Reference Config File #
########################################
# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.
akka.http {
server {
# The default value of the `Server` header to produce if no
# explicit `Server`-header was included in a response.
# If this value is the empty string and no header was included in
# the request, no `Server` header will be rendered at all.
server-header = akka-http/${akka.version}
# The time after which an idle connection will be automatically closed.
# Set to `infinite` to completely disable idle connection timeouts.
idle-timeout = 60 s
# Defines the default time period within which the application has to
# produce an HttpResponse for any given HttpRequest it received.
# The timeout begins to run when the *end* of the request has been
# received, so even potentially long uploads can have a short timeout.
# Set to `infinite` to completely disable request timeout checking.
#
# If this setting is not `infinite` the HTTP server layer attaches a
# `Timeout-Access` header to the request, which enables programmatic
# customization of the timeout period and timeout response for each
# request individually.
request-timeout = 20 s
# The time period within which the TCP binding process must be completed.
bind-timeout = 1s
# The maximum number of concurrently accepted connections when using the
# `Http().bindAndHandle` methods.
#
# This setting doesn't apply to the `Http().bind` method which will still
# deliver an unlimited backpressured stream of incoming connections.
max-connections = 1024
# The maximum number of requests that are accepted (and dispatched to
# the application) on one single connection before the first request
# has to be completed.
# Incoming requests that would cause the pipelining limit to be exceeded
# are not read from the connections socket so as to build up "back-pressure"
# to the client via TCP flow control.
# A setting of 1 disables HTTP pipelining, since only one request per
# connection can be "open" (i.e. being processed by the application) at any
# time. Set to higher values to enable HTTP pipelining.
# This value must be > 0 and <= 1024.
pipelining-limit = 16
# Enables/disables the addition of a `Remote-Address` header
# holding the clients (remote) IP address.
remote-address-header = off
# Enables/disables the addition of a `Raw-Request-URI` header holding the
# original raw request URI as the client has sent it.
raw-request-uri-header = off
# Enables/disables automatic handling of HEAD requests.
# If this setting is enabled the server dispatches HEAD requests as GET
# requests to the application and automatically strips off all message
# bodies from outgoing responses.
# Note that, even when this setting is off the server will never send
# out message bodies on responses to HEAD requests.
transparent-head-requests = on
# Enables/disables the returning of more detailed error messages to
# the client in the error response.
# Should be disabled for browser-facing APIs due to the risk of XSS attacks
# and (probably) enabled for internal or non-browser APIs.
# Note that akka-http will always produce log messages containing the full
# error details.
verbose-error-messages = off
# The initial size of the buffer to render the response headers in.
# Can be used for fine-tuning response rendering performance but probably
# doesn't have to be fiddled with in most applications.
response-header-size-hint = 512
# The requested maximum length of the queue of incoming connections.
# If the server is busy and the backlog is full the OS will start dropping
# SYN-packets and connection attempts may fail. Note, that the backlog
# size is usually only a maximum size hint for the OS and the OS can
# restrict the number further based on global limits.
backlog = 100
# If this setting is empty the server only accepts requests that carry a
# non-empty `Host` header. Otherwise it responds with `400 Bad Request`.
# Set to a non-empty value to be used in lieu of a missing or empty `Host`
# header to make the server accept such requests.
# Note that the server will never accept HTTP/1.1 request without a `Host`
# header, i.e. this setting only affects HTTP/1.1 requests with an empty
# `Host` header as well as HTTP/1.0 requests.
# Examples: `www.spray.io` or `example.com:8080`
default-host-header = ""
# Socket options to set for the listening socket. If a setting is left
# undefined, it will use whatever the default on the system is.
socket-options {
so-receive-buffer-size = undefined
so-send-buffer-size = undefined
so-reuse-address = undefined
so-traffic-class = undefined
tcp-keep-alive = undefined
tcp-oob-inline = undefined
tcp-no-delay = undefined
}
# Modify to tweak parsing settings on the server-side only.
parsing {
# no overrides by default, see `akka.http.parsing` for default values
}
}
client {
# The default value of the `User-Agent` header to produce if no
# explicit `User-Agent`-header was included in a request.
# If this value is the empty string and no header was included in
# the request, no `User-Agent` header will be rendered at all.
user-agent-header = akka-http/${akka.version}
# The time period within which the TCP connecting process must be completed.
connecting-timeout = 10s
# The time after which an idle connection will be automatically closed.
# Set to `infinite` to completely disable idle timeouts.
idle-timeout = 60 s
# The initial size of the buffer to render the request headers in.
# Can be used for fine-tuning request rendering performance but probably
# doesn't have to be fiddled with in most applications.
request-header-size-hint = 512
# Socket options to set for the listening socket. If a setting is left
# undefined, it will use whatever the default on the system is.
socket-options {
so-receive-buffer-size = undefined
so-send-buffer-size = undefined
so-reuse-address = undefined
so-traffic-class = undefined
tcp-keep-alive = undefined
tcp-oob-inline = undefined
tcp-no-delay = undefined
}
# Modify to tweak parsing settings on the client-side only.
parsing {
# no overrides by default, see `akka.http.parsing` for default values
}
}
host-connection-pool {
# The maximum number of parallel connections that a connection pool to a
# single host endpoint is allowed to establish. Must be greater than zero.
max-connections = 4
# The minimum number of parallel connections that a pool should keep alive ("hot").
# If the number of connections is falling below the given threshold, new ones are being spawned.
# You can use this setting to build a hot pool of "always on" connections.
# Default is 0, meaning there might be no active connection at given moment.
# Keep in mind that `min-connections` should be smaller than `max-connections` or equal
min-connections = 0
# The maximum number of times failed requests are attempted again,
# (if the request can be safely retried) before giving up and returning an error.
# Set to zero to completely disable request retries.
max-retries = 5
# The maximum number of open requests accepted into the pool across all
# materializations of any of its client flows.
# Protects against (accidentally) overloading a single pool with too many client flow materializations.
# Note that with N concurrent materializations the max number of open request in the pool
# will never exceed N * max-connections * pipelining-limit.
# Must be a power of 2 and > 0!
max-open-requests = 32
# The maximum number of requests that are dispatched to the target host in
# batch-mode across a single connection (HTTP pipelining).
# A setting of 1 disables HTTP pipelining, since only one request per
# connection can be "in flight" at any time.
# Set to higher values to enable HTTP pipelining.
# This value must be > 0.
# (Note that, independently of this setting, pipelining will never be done
# on a connection that still has a non-idempotent request in flight.
#
# Before increasing this value, make sure you understand the effects of head-of-line blocking.
# Using a connection pool, a request may be issued on a connection where a previous
# long-running request hasn't finished yet. The response to the pipelined requests may then be stuck
# behind the response of the long-running previous requests on the server. This may introduce an
# unwanted "coupling" of run time between otherwise unrelated requests.
#
# See http://tools.ietf.org/html/rfc7230#section-6.3.2 for more info.)
pipelining-limit = 1
# The time after which an idle connection pool (without pending requests)
# will automatically terminate itself. Set to `infinite` to completely disable idle timeouts.
idle-timeout = 30 s
# Modify to tweak client settings for host connection pools only.
#
# IMPORTANT:
# Please note that this section mirrors `akka.http.client` however is used only for pool-based APIs,
# such as `Http().superPool` or `Http().singleRequest`.
client = {
# The default value of the `User-Agent` header to produce if no
# explicit `User-Agent`-header was included in a request.
# If this value is the empty string and no header was included in
# the request, no `User-Agent` header will be rendered at all.
user-agent-header = akka-http/${akka.version}
# The time period within which the TCP connecting process must be completed.
connecting-timeout = 10s
# The time after which an idle connection will be automatically closed.
# Set to `infinite` to completely disable idle timeouts.
idle-timeout = 60 s
# The initial size of the buffer to render the request headers in.
# Can be used for fine-tuning request rendering performance but probably
# doesn't have to be fiddled with in most applications.
request-header-size-hint = 512
# The proxy configurations to be used for requests with the specified
# scheme.
proxy {
# Proxy settings for unencrypted HTTP requests
# Set to 'none' to always connect directly, 'default' to use the system
# settings as described in http://docs.oracle.com/javase/6/docs/technotes/guides/net/proxies.html
# or specify the proxy host, port and non proxy hosts as demonstrated
# in the following example:
# http {
# host = myproxy.com
# port = 8080
# non-proxy-hosts = ["*.direct-access.net"]
# }
http = default
# Proxy settings for HTTPS requests (currently unsupported)
https = default
}
# Socket options to set for the listening socket. If a setting is left
# undefined, it will use whatever the default on the system is.
socket-options {
so-receive-buffer-size = undefined
so-send-buffer-size = undefined
so-reuse-address = undefined
so-traffic-class = undefined
tcp-keep-alive = undefined
tcp-oob-inline = undefined
tcp-no-delay = undefined
}
# IMPORTANT: Please note that this section is replicated in `client` and `server`.
parsing {
# no overrides by default, see `akka.http.parsing` for default values
}
}
}
# Modify to tweak default parsing settings.
#
# IMPORTANT:
# Please note that this sections settings can be overriden by the corresponding settings in:
# `akka.http.server.parsing`, `akka.http.client.parsing` or `akka.http.host-connection-pool.client.parsing`.
parsing {
# The limits for the various parts of the HTTP message parser.
max-uri-length = 2k
max-method-length = 16
max-response-reason-length = 64
max-header-name-length = 64
max-header-value-length = 8k
max-header-count = 64
max-chunk-ext-length = 256
max-chunk-size = 1m
# Default maximum content length which should not be exceeded by incoming request entities.
# Can be changed at runtime (to a higher or lower value) via the `HttpEntity::withSizeLimit` method.
# Note that it is not necessarily a problem to set this to a high value as all stream operations
# are always properly backpressured.
# Nevertheless you might want to apply some limit in order to prevent a single client from consuming
# an excessive amount of server resources.
#
# Set to `infinite` to completely disable entity length checks. (Even then you can still apply one
# programmatically via `withSizeLimit`.)
max-content-length = 8m
# Sets the strictness mode for parsing request target URIs.
# The following values are defined:
#
# `strict`: RFC3986-compliant URIs are required,
# a 400 response is triggered on violations
#
# `relaxed`: all visible 7-Bit ASCII chars are allowed
#
uri-parsing-mode = strict
# Sets the parsing mode for parsing cookies.
# The following value are defined:
#
# `rfc6265`: Only RFC6265-compliant cookies are parsed. Surrounding double-quotes are accepted and
# automatically removed. Non-compliant cookies are silently discarded.
# `raw`: Raw parsing allows any non-control character but ';' to appear in a cookie value. There's no further
# post-processing applied, so that the resulting value string may contain any number of whitespace, unicode,
# double quotes, or '=' characters at any position.
# The rules for parsing the cookie name are the same ones from RFC 6265.
#
cookie-parsing-mode = rfc6265
# Enables/disables the logging of warning messages in case an incoming
# message (request or response) contains an HTTP header which cannot be
# parsed into its high-level model class due to incompatible syntax.
# Note that, independently of this settings, akka-http will accept messages
# with such headers as long as the message as a whole would still be legal
# under the HTTP specification even without this header.
# If a header cannot be parsed into a high-level model instance it will be
# provided as a `RawHeader`.
# If logging is enabled it is performed with the configured
# `error-logging-verbosity`.
illegal-header-warnings = on
# Configures the verbosity with which message (request or response) parsing
# errors are written to the application log.
#
# Supported settings:
# `off` : no log messages are produced
# `simple`: a condensed single-line message is logged
# `full` : the full error details (potentially spanning several lines) are logged
error-logging-verbosity = full
# Configures the processing mode when encountering illegal characters in
# header value of response.
#
# Supported mode:
# `error` : default mode, throw an ParsingException and terminate the processing
# `warn` : ignore the illegal characters in response header value and log a warning message
# `ignore` : just ignore the illegal characters in response header value
illegal-response-header-value-processing-mode = error
# limits for the number of different values per header type that the
# header cache will hold
header-cache {
default = 12
Content-MD5 = 0
Date = 0
If-Match = 0
If-Modified-Since = 0
If-None-Match = 0
If-Range = 0
If-Unmodified-Since = 0
User-Agent = 32
}
# Enables/disables inclusion of an Tls-Session-Info header in parsed
# messages over Tls transports (i.e., HttpRequest on server side and
# HttpResponse on client side).
tls-session-info-header = off
}
}
akka-http
#######################################
# akka-http Reference Config File #
#######################################
# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.
akka.http.routing {
# Enables/disables the returning of more detailed error messages to the
# client in the error response
# Should be disabled for browser-facing APIs due to the risk of XSS attacks
# and (probably) enabled for internal or non-browser APIs
# (Note that akka-http will always produce log messages containing the full error details)
verbose-error-messages = off
# Enables/disables ETag and `If-Modified-Since` support for FileAndResourceDirectives
file-get-conditional = on
# Enables/disables the rendering of the "rendered by" footer in directory listings
render-vanity-footer = yes
# The maximum size between two requested ranges. Ranges with less space in between will be coalesced.
#
# When multiple ranges are requested, a server may coalesce any of the ranges that overlap or that are separated
# by a gap that is smaller than the overhead of sending multiple parts, regardless of the order in which the
# corresponding byte-range-spec appeared in the received Range header field. Since the typical overhead between
# parts of a multipart/byteranges payload is around 80 bytes, depending on the selected representation's
# media type and the chosen boundary parameter length, it can be less efficient to transfer many small
# disjoint parts than it is to transfer the entire selected representation.
range-coalescing-threshold = 80
# The maximum number of allowed ranges per request.
# Requests with more ranges will be rejected due to DOS suspicion.
range-count-limit = 16
# The maximum number of bytes per ByteString a decoding directive will produce
# for an entity data stream.
decode-max-bytes-per-chunk = 1m
# Fully qualified config path which holds the dispatcher configuration
# to be used by FlowMaterialiser when creating Actors for IO operations.
file-io-dispatcher = ${akka.stream.blocking-io-dispatcher}
}
The other Akka HTTP modules do not offer any configuration via Typesafe Config.
Contents


Changed made by: {{c.user_name}}
Description: {{c.comment}}
Date: {{c.created_at | date:'EEE MMM d y HH:mm UTC':'UTC'}}


The rooms are extremely comfortable, equipped with warm and precious materials and personalized with authentic antiques expertly chosen one by one in the many markets of Tuscany. This passion for detail contributes to the intimate, tranquil atmosphere which transforms each room into a pleasant refuge, in a place where guests can relax after a day spent touring and admiring the many beautiful landscapes which cradled the Renaissance. Each bedroom has been individually designed in a fresh concept mixing tradition, precious fabrics, period furnitures, Maasai vintage design, original photos, prints and paintings. Rooms are light and comfortable and well appointed with a writing desk, wireless internet access and flat screen TV's. Rooms overlooking the front have double soundproof windows.


The professional committee is responsible for planning professional events, such as information sessions with companies like Genentech and Chevron, and student and professor panels regarding research or graduate school. In addition, we work with the American Chemical Society (ACS) to host seminars to show how chemistry is applied to different jobs and fields. We also volunteer at ACS outreach events every semester, including Family Science Night. To support the College of Chemistry, we help out at their semesterly events: AutumnFest and SpringFest. Our members-only workshop series, called ProTalks, teaches skills that can be applied to brothers' academic and professional careers. Our two main networking events are Pizza with Professors in the Fall and Wine and Cheese in the Spring, typically held in 775 Tan Hall.
The Social Committee plans fun activities for the brothers, including Assassins, frisbee on Memorial Glade, Korean barbeque, and weekend
trips to San Francisco. The brothers also bond at volunteering events, including Berkeley Project and Suicide Prevention
Walk. At the beginning of every semester, the Vice President and Social Chair plan an overnight retreat; in the past, we have gone to
Monterey Bay and Lake Tahoe. Recently, we have been hanging out with our fellow brothers from the Alpha Alpha Chapter at Stanford University!
Every year, the Banquet Committee organizes and executes an end-of-the-school-year banquet for members and alumni. It is a great event
for current members to connect with alumni and faculty and to reflect on the memories that were made during the year.
The Tutoring Committee provides academic resources to the fraternity and student body. Our resources include a test bank for brothers only and weekly study sessions. We also host workshops on topics such as interpreting NMR spectrums and writing effective lab reports. Office hours in 121 Gilman Hall are offered in chemistry and most of the pre-req chemistry major classes. Check out the Alpha Chi Sigma Tutoring Facebook page for more information.
The Fundraising Committee’s goal is to raise money for the fraternity. We typically host our fundraisers in the Chemistry Plaza, but in the past few semesters, we expanded to Sproul Plaza with our In-N-Out and Thai Ice Tea fundraisers. We also host off-campus fundraisers with businesses, such as ShareTea and Menchie’s. In the Fall, we sell the parking spots at our house for football games, and in the Spring, our Cal Day fundraiser is the periodic table of cupcakes.


This article is part of the Beginner Web Developer Series. The series is targeted to people who’d like to start serious web development, as well as people who are already web developers and want to solidify their knowledge of fundamentals while possibly filling in some holes. If you find yourself tinkering with HTML, CSS, or Javascript until you sort of get it to work, this series is for you. The material in this series is closely tied to my top-rated Coursera course.
This article is part of the Beginner Web Developer Series. The series is targeted to people who’d like to start serious web development, as well as people who are already web developers and want to solidify their knowledge of fundamentals while possibly filling in some holes. If you find yourself tinkering with HTML, CSS, or Javascript until you sort of get it to work, this series is for you. The material in this series is closely tied to my top-rated Coursera course.
This article is part of the Beginner Web Developer Series. The series is targeted to people who’d like to start serious web development, as well as people who are already web developers and want to solidify their knowledge of fundamentals while possibly filling in some holes. If you find yourself tinkering with HTML, CSS, or Javascript until you sort of get it to work, this series is for you. The material in this series is closely tied to my top-rated Coursera course.


Unity VR: WorldSpace UI Performance Optimizations
9 September 2017
For the past six months I’ve been working on a city-building sim named Skytropolis for VR & Desktop in Unity. Early on we realized a need for a UI (user interface) where the player could choose which buildings they would want to add to their city. Instead of creating a typical, uninspired flat UI and pointing a laser pointer at scrollbars and menus (similar to using a web browser) we decided to create a card deck concept where you choose buildings from your card hand (similar to any card game you’ve played).
One of the largest challenges so far while developing Skytropolis has been solving the best ways to keep performance smooth. We need to hit and keep the game at over 90FPS for the Vive & Rift, while maintaining a visually interesting aesthetic.
One of the things we noticed was that performance was dropping after we rolled out a new update to this card UI. Each time a card category with more than 10+ cards was chosen, the frame rate would drop to around 50 - 60 FPS.
Digging in to Unity’s profiler showed that re-draws of the UI each time the player moved their hand was the issue.
The hierarchy of the cards, their Images & TextMeshPro objects looked like so:
Each element in the tree above is a GameObject. And in typical Unity fashion, each GameObject has a Transform, which controls it’s position, rotation and scale in the world. When the card hand is open, and the player moves their hand the VRCardUISystem
loosely follows the hand around so the UI is always available and ready to use.
This turned out to be the biggest issue with the cards. As the VRCardUISystem
Transform follows the player’s hand, and their hand moves every single frame (even miniscule amounts are picked up by the VR sensors) under the hood Unity has to tell every child Transform what it’s new position is, move it there, then send that to the graphics pipeline for rendering to the player’s headset screens.
After a few various attempts at improving performance via other means, such as changing the VRCardUISystem
’s update rate to not happen every frame, and using object pooling instead of Instantiate()
and Destroy()
we found the performance issue still existed.
The solution was to simplify. I had read somewhere that Unity prefers very simple hierarchy, and instead of grouping objects together logically (which is easier for the developers and level editors to consume), it ideally wants every GameObject (and Transform) to be at the root level. This is a mess for us developers to read, but helps it’s internal systems.
On top of removing the container groups, we decided about half of the Unity Image
components could be baked into one PNG background sprite in Photoshop, as could the Demands Images and Services Arrows (showing the player how this building will affect their city’s demands, surplus and service import / export costs). This resulted in each card only having 20 child GameObjects (and Transforms) instead of 59. And when you have 20 cards in your hand, that means only 400 GameObjects (and Transforms) instead of 1,180!
Coincidentally, this also improved a performance issue we were experiencing when using these same VRUICard
prefabs on the Desktop version of the game (yes, we have yet to refactor the naming convention on these so they apply to both version of the game 😊).
Further Improvements: TextMeshPro Mobile Shader & Material Presets
After using Unity 3 and 4 for a while, I found the default Text
component lacking. The result of text was almost always blurry, and the hack to make it crisper (size the font waaay up and scale the transform waaay down) felt silly. After learning about TextMeshPro, and all the amazing improvements it offered I thought it would be ideal to use in VR for Skytropolis. Thankfully, Unity agreed and purchased TextMeshPro to provide it for free to all of us Unity game developers.
Integrating TextMeshPro properly came with it’s own learning curve. Thankfully there is fantastic documentation and forum discussion on how to use it best. Here’s my notes on what I found most beneficial:
If you’re not using any of TextMeshPro’s advanced features (glow, bevel, lighting, etc), the recommendation is to use the simpler TextMeshPro Mobile Shader.
Also, it’s recommended to use Material Presets. We use one font and therefore, one TextMeshPro font asset, with 2 material presets. One material preset is for any UI canvas elements (TextMeshPro UGUI components), and another is for regular TextMeshPro components (meshes drawn in the world that aren’t children of a UI canvas). This is important so that each piece of text shows up correctly based on it’s layer (Z-depth), and the mobile shader is to keep the text as simple as possible for the engine to render.
More on the TextMeshPro Mobile Shader: Mobile Shader on YouTube
More on material presets: Material Presets on YouTube
Conclusion
Wrapping up, it’s important to keep Unity’s hierarchy simple. To use one baked image when possible (instead of multiple image components), and to use TextMeshPro’s Mobile Shader & Material Presets.
Happy performant game developing!
😄


It's pretty simple to coock it. We should use just common ingridients
Actually, the main trick in using it


|
Dear Friends of the Dictionary of Old English,
As we mark the 50th anniversary of our epic quest to create the Dictionary of Old English (DOE), we’d like to offer you the opportunity to be a part of the next chapter. We’re excited to inform you the DOE has reached a milestone in its journey. With editors now working on the letter “L,” more than 60 per cent of the dictionary’s 35,000 entries have been written and more than 50 per cent published.
But with COVID-19 continuing to grip the world, we’re also reminded of cwyld and wōl, Old English words for “fatal epidemic” or “pestilence.”
Our quest is ambitious even in the best times, and, as we navigate this uncharted territory, the DOE is more dependent than ever on the philanthropic support of individuals like you, as government and humanities funding continues to shrink.
Read the heartwarming story about DOE donor and former Victoria College Chancellor Wendy Cecil adopting DOE words for the names of her grandchildren.
We understand these are difficult times for everyone.
If you have supported the DOE in the past, we are deeply grateful for your generosity and hope you are still able to support us.
And if you have been enjoying free access to the DOE online and its Word of The Week feature but haven’t made a donation yet, we hope you will consider helping us now if you are able.
Founded by the late Professor Angus Cameron in 1970 at the University of Toronto — Canada’s leading research university — the DOE is a globally significant contribution to the story of English, mapping all known words from the earliest form of the language (600-1150 CE).
When it is completed, the DOE — together with the Middle English Dictionary and the Oxford English Dictionary — will provide a full description of the history of English. The final instalment of the lexicographic trilogy, if you will.
Indeed, a visiting scholar recently discovered handwritten notes from the author of the Lord of the Rings trilogy during their research at the DOE. A former editorial assistant at the OED, J.R.R. Tolkien drew on Old English for inspiration for words such as ent or “giant,” from which he fashioned the towering tree shepherds of his tales.
Scholars all over the world rely on the DOE for their research. As a pioneer in the application of technology to lexicography, the DOE has made its scholarship accessible over the internet and revolutionized how humanities research is conducted, creating an electronic copy of every surviving text from the Old English period, whether written on parchment, carved in stone or inscribed on metal.
It’s also a source of joy and fascination for the lover of words and history in all of us.
 Most of the words for the parts of our bodies like “head,” “heart,” “arm” and “foot” are from Old English, as are the interrogatives “who,” “what,” “where,” “when” and “why.”
The DOE is not just an exercise in lexicography; it traces the evolution of people’s ideas and beliefs, like fate and heroism.
We’ve all been inspired by those who have demonstrated the spirit of resilience during this pandemic by reaching out to help.
Give online today or you can complete and return the enclosed pledge form. And visit the DOE website to see how your support will help us complete the Dictionary of Old English and preserve the origins of this remarkable language for centuries to come.
With your generous help, this trailblazing journey with a 50-year legacy already behind it will continue on its historic quest.
Sincerely,
Richard DeLisle
Senior Development Officer
Faculty of Arts & Science
<EMAIL_ADDRESS>416-978-2720
P.S. With a minimum donation of $1,000 — just $84 a month — you can adopt a word in the Dictionary of Old English, either in your own name or as a tribute to a friend, loved one or special occasion. Please contact<EMAIL_ADDRESS>to get suggestions and request a specific word or theme.
|


| Package | Description |
|---|---|
| com.ibm.team.build.common.model | |
| com.ibm.team.enterprise.buildablesubset.client | |
| com.ibm.team.enterprise.buildablesubset.common.dto | |
| com.ibm.team.process.client | |
| com.ibm.team.process.common | |
| com.ibm.team.reports.common | |
| com.ibm.team.reports.common.service | |
| com.ibm.team.repository.client |
Provides the main client-side-only APIs for the Repository component.
|
| com.ibm.team.repository.common |
Provides APIs for the Repository component that are common to both the
client-side and the server-side.
|
| com.ibm.team.scm.client | |
| com.ibm.team.scm.common | |
| com.ibm.team.scm.common.dto | |
| com.ibm.team.workitem.common | |
| com.ibm.team.workitem.common.expression.variables | |
| com.ibm.team.workitem.common.model | |
| com.ibm.team.workitem.common.query | |
| com.ibm.team.workitem.common.template |
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IBuildRequest.getHandlingContributor()
Retrieves the handle of the contributor that initiated the process to
fulfill the build request.
|
IContributorHandle |
IBuildRequest.getInitiatingContributor()
Retrieves the handle of the contributor that initiated the build request.
|
| Modifier and Type | Method and Description |
|---|---|
void |
IBuildRequest.setHandlingContributor(IContributorHandle contributorHandle)
Sets the handle of the contributor that initiated the the process to
fulfill the build request.
|
void |
IBuildRequest.setInitiatingContributor(IContributorHandle contributorHandle)
Sets the handle of the contributor that initiated the build request.
|
| Modifier and Type | Method and Description |
|---|---|
IBuildableSubset2 |
IBuildableSubsetClientAPI.createBuildableSubset(java.lang.String name,
IContributorHandle owner,
com.ibm.team.enterprise.buildablesubset.common.dto.Visibility visibility,
IBuildDefinitionHandle buildDefinitionHandle,
IBuildableFileDesc2[] buildableFileDescs,
org.eclipse.core.runtime.IProgressMonitor monitor)
Create a new buildable subset with the given name and the associated build definition.
|
IBuildableSubset2 |
IBuildableSubsetClientAPI.createBuildableSubsetFromWorkItems(java.lang.String name,
IContributorHandle owner,
com.ibm.team.enterprise.buildablesubset.common.dto.Visibility visibility,
IBuildDefinitionHandle buildDefinitionHandle,
IWorkItemHandle[] workItemHandles,
boolean includeWorkItemChildren,
boolean includeImpacts,
org.eclipse.core.runtime.IProgressMonitor monitor)
Create a new buildable subset with the given name and the associated build definition.
|
IBuildableSubset2 |
IBuildableSubsetClientAPI.createBuildableSubsetFromWorkItems2(java.lang.String name,
IContributorHandle owner,
com.ibm.team.enterprise.buildablesubset.common.dto.Visibility visibility,
IBuildDefinitionHandle buildDefinitionHandle,
IWorkItemHandle[] workItemHandles,
IWorkItemHandle[] dynamicWorkItems,
boolean includeWorkItemChildren,
boolean includeImpacts,
org.eclipse.core.runtime.IProgressMonitor monitor)
Create a new buildable subset with the given name and the associated build definition.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IBuildableSubset2.getOwner()
Get the owner of the buildable subset.
|
| Modifier and Type | Method and Description |
|---|---|
void |
IBuildableSubset2.setOwner(IContributorHandle owner)
set the owner of the subset
|
| Modifier and Type | Method and Description |
|---|---|
IRole[] |
IClientProcess.getContributorRoles(IContributorHandle contributor,
IProcessArea processArea,
org.eclipse.core.runtime.IProgressMonitor monitor)
Returns the roles assigned to the given contributor relative to the given
process area.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle[] |
IProcessArea.getAdministrators()
Returns the collection of users who are responsible for administering the
process area.
|
IContributorHandle[] |
IReadAccessList.getContributors()
Returns the collection of contributors who have access.
|
IContributorHandle[] |
IProcessArea.getMembers()
Returns an array of handles representing the contributors constituting
the team members of this process area.
|
| Modifier and Type | Method and Description |
|---|---|
void |
IAccessGroup.add(IContributorHandle contributorHandle)
Adds a contributor to the access group.
|
void |
IProcessArea.addAdministrator(IContributorHandle contributorHandle)
Adds the contributor represented by the given handle to the set of
contributors constituting the administrators of this process area.
|
void |
IReadAccessList.addContributors(IContributorHandle[] contributors)
Adds the given contributors to the collection of contributors who have
access.
|
void |
IProcessArea.addMember(IContributorHandle contributorHandle)
Adds the contributor represented by the given handle to the set of
contributors constituting the members of this process area.
|
void |
IProcessArea.addRoleAssignments(IContributorHandle contributor,
IRole[] roles)
Appends the given roles to the collection of roles assigned to the given
contributor.
|
java.lang.String |
ITeamData.getContributorData(IContributorHandle contributor,
java.lang.String key) |
java.lang.String[] |
ITeamData.getContributorRoleIds(IContributorHandle contributor) |
java.lang.String[] |
IProcessArea.getRoleAssignmentIds(IContributorHandle contributor)
Returns the collection of role ids which are assigned to the given
contributor in this process area.
|
IRole[] |
IProcessArea.getRoleAssignments(IContributorHandle contributor,
IRole[] availableRoles)
Returns the subset of the given collection of available roles which are
assigned to the given contributor in this process area.
|
boolean |
IProcessArea.hasAdministrator(IContributorHandle contributorHandle)
Returns
true if the contributor represented by the given
handle is an administrator of this team, false otherwise. |
boolean |
IProcessArea.hasMember(IContributorHandle contributorHandle)
Returns
true if the contributor represented by the given
handle is a member of this team, false otherwise. |
void |
IAccessGroup.remove(IContributorHandle contributorHandle)
Removes a contributor from the access group.
|
void |
IProcessArea.removeAdministrator(IContributorHandle contributorHandle)
Removes the contributor represented by the given handle from the set of
contributors constituting the administrators of this process area.
|
void |
IReadAccessList.removeContributors(IContributorHandle[] contributors)
Removes the given contributors from the collection of contributors who
have access.
|
void |
IProcessArea.removeMember(IContributorHandle contributorHandle)
Removes the contributor represented by the given handle from the set of
contributors constituting the members of this process area.
|
void |
IProcessArea.removeRoleAssignments(IContributorHandle contributor,
IRole[] rolesToRemove)
Removes the given roles from the collection of roles assigned to the
given contributor.
|
void |
IProcessArea.setAdministrators(IContributorHandle[] administrators)
Sets the collection of users who are responsible for administering the
process area.
|
void |
ITeamData.setContributorData(IContributorHandle contributor,
java.lang.String key,
java.lang.String value) |
void |
IReadAccessList.setContributors(IContributorHandle[] contributors)
Sets the collection of contributors who have access.
|
void |
IProcessArea.setRoleAssignments(IContributorHandle contributor,
IRole[] roles)
Sets the collection of roles assigned to the given contributor.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
ISharableDescriptor.getOwner()
Returns the owner of this descriptor.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ISharableDescriptor.setup(IProjectAreaHandle projectArea,
IProcessAreaHandle processArea,
IContributorHandle owner)
Sets up the various properties of this item.
|
void |
ISharableDescriptor.setup(IProjectAreaHandle projectArea,
IProcessAreaHandle processArea,
IContributorHandle owner,
boolean shared)
Sets up the various properties of this item.
|
| Modifier and Type | Method and Description |
|---|---|
IFolderDescriptor[] |
IReportService.fetchFolderDescriptors(IContributorHandle owner,
IProjectAreaHandle projectArea,
IProcessAreaHandle[] processAreas,
IFolderDescriptorHandle parent,
int flags)
Fetch folder descriptors meeting the parameter criteria.
|
IReportQueryDescriptor[] |
IReportService.fetchQueryDescriptors(IContributorHandle owner,
IProjectAreaHandle projectArea,
IProcessAreaHandle[] processAreas,
IReportDescriptorHandle report,
IFolderDescriptorHandle folder,
int flags)
Fetch query descriptors meeting the parameter criteria.
|
IReportDescriptor[] |
IReportService.fetchReportDescriptors(IContributorHandle owner,
IProjectAreaHandle projectArea,
IProcessAreaHandle[] processAreas,
java.lang.String snapshotName,
java.lang.String[] parameters,
int flags)
Fetches report descriptors meeting the parameter criteria.
|
IFolderDescriptor[] |
IReportService.fetchRootFolderDescriptors(IContributorHandle owner,
IProjectAreaHandle projectArea,
IProcessAreaHandle[] processAreas,
int flags)
Fetch root folder descriptors meeting the parameter criteria.
|
IProcessAreaHandle |
IReportService.getDefaultProcessArea(IProjectAreaHandle projectArea,
IContributorHandle contributor)
Fetch the default process area for a given project area and contributor.
|
IReportQueryDescriptorHandle |
IReportService.getDefaultQueryDescriptor(IContributorHandle contributor,
IProjectAreaHandle projectArea)
Return the default query descriptor for the given contributor, or null if
there is no default query descriptor.
|
void |
IReportService.setDefaultQueryDescriptor(IContributorHandle contributor,
IReportQueryDescriptorHandle queryHandle)
Set the default query for the given contributor, in the given project
area, to the query descriptor specified.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ILicenseClient.assertLicenseForContributor(java.lang.String operationId,
IContributorHandle contributor,
org.eclipse.core.runtime.IProgressMonitor monitor)
Asserts that the given Contributor has a license to perform the operation requested.
|
void |
IContributorManager.deleteContributor(IContributorHandle contributorHandle,
org.eclipse.core.runtime.IProgressMonitor monitor)
NOTE: This method should NEVER be executed by any application or tools except those that are delivered
as part of the Jazz Team Server.
|
IContributorDetails |
IContributorManager.setContributorDetails(IContributorHandle contributorHandle,
IContributorDetails detailsWorkingCopy,
org.eclipse.core.runtime.IProgressMonitor monitor)
Creates or updates the given contributor details in the repository.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
IContributor
Represents a contributor known to the repository.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IChangeEvent.getAuthor()
Returns a handle to the contributor that created this repository
modification.
|
IContributorHandle[] |
ILicenseAdminService.getLicensedContributors(java.lang.String licenseId)
Returns a list of contributors who have been assigned the given license.
|
IContributorHandle |
IItem.getModifiedBy()
Returns the contributor responsible for creating this state of the item.
|
IContributorHandle |
IAuditableBaseline.getOwner()
Get the owner of the baseline.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.Set<IContributorHandle> |
ILicenseAdminService.BatchResult.getFailed() |
| Modifier and Type | Method and Description |
|---|---|
void |
ILicenseService.assertLicenseAndAssignForContributor(java.lang.String operationId,
IContributorHandle contributor)
Asserts that the given Contributor has a license to perform the operation
requested.
|
void |
ILicenseService.assertLicenseForContributor(java.lang.String operationId,
IContributorHandle contributor)
Asserts that the given Contributor has a license to perform the operation
requested.
|
void |
ILicenseAdminService.assignLicense(IContributorHandle contributor,
java.lang.String licenseId)
Assigns a license to a contributor.
|
ILicenseAssignmentResult |
ILicenseAdminService.assignLicenseWithResult(IContributorHandle handle,
java.lang.String licenseId)
Assigns a license to a user and returns an object representing the result
of the assignment.
|
java.lang.String[] |
ILicenseService.checkLicensesForContributor(java.lang.String[] opIds,
IContributorHandle contributor)
Checks that the passed in user has a license to perform the listed
operation ids.
|
void |
ILicenseAdminService.BatchResult.failure(IContributorHandle handle,
java.lang.String message) |
java.lang.String[] |
ILicenseAdminService.getAssignedLicenses(IContributorHandle contributor)
Returns the set of assigned licenses for a given contributor.
|
java.lang.String |
ILicenseAdminService.BatchResult.getError(IContributorHandle handle) |
ILicenseAdminService.BatchResult |
ILicenseAdminService.reassignLicense(java.lang.String sourceLicenseId,
java.lang.String targetLicenseId,
IContributorHandle... contributors)
Reassigns the users from the source license to the target license.
|
void |
IChangeEvent.setAuthor(IContributorHandle author)
Sets the contributor that created this repository modification.
|
void |
IAuditableBaseline.setOwner(IContributorHandle owner)
Set the owner of the baseline.
|
void |
ILicenseAdminService2.terminateLeases(IContributorHandle handle)
Terminates the floating license leases associated with the specified user.
|
void |
ILicenseAdminService.unassignAllLicenses(IContributorHandle contributor)
Unassigns all licenses from a contributor.
|
void |
ILicenseAdminService.unassignLicense(IContributorHandle contributor,
java.lang.String licenseId)
Unassigns a license from a contributor.
|
| Constructor and Description |
|---|
ILicenseAdminService.ResultMapEntry(IContributorHandle handle,
java.lang.String message) |
| Modifier and Type | Method and Description |
|---|---|
IWorkspaceConnection |
IWorkspaceManager.createWorkspace(IContributorHandle scopeHandle,
java.lang.String workspaceName,
java.lang.String description,
IBaselineSetHandle sourceBaselineSet,
org.eclipse.core.runtime.IProgressMonitor progressMonitor)
Creates a workspace in the repository.
|
IWorkspaceConnection |
IWorkspaceManager.createWorkspace(IContributorHandle scopeHandle,
java.lang.String workspaceName,
java.lang.String description,
com.ibm.team.scm.common.IHistoryReference seed,
org.eclipse.core.runtime.IProgressMonitor monitor)
Create a workspace in the repository based on the given history seed.
|
IWorkspaceConnection |
IWorkspaceManager.createWorkspace(IContributorHandle scopeHandle,
java.lang.String workspaceName,
java.lang.String description,
org.eclipse.core.runtime.IProgressMonitor monitor)
Creates an empty workspace in the repository.
|
IWorkspaceConnection |
IWorkspaceManager.createWorkspace(IContributorHandle scopeHandle,
java.lang.String workspaceName,
java.lang.String description,
IWorkspaceConnection defaultFlow,
IWorkspaceConnection sourceWorkspace,
org.eclipse.core.runtime.IProgressMonitor progressMonitor)
Creates a workspace in the repository.
|
IWorkspaceManager.IVersionableLockOperation |
IWorkspaceManager.IVersionableLockOperationFactory.transfer(IVersionableHandle versionable,
IWorkspaceConnection stream,
IComponentHandle component,
IContributorHandle contributor) |
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IChangeHistoryEntry.createdBy()
Returns the contributor that created this entry in the change history using
one of createChangeSet(), deliver() or accept().
|
IContributorHandle |
IComponentInfo.deliveredBy()
Returns the contributor that delivered the current base for this component
to the workspace.
|
IContributorHandle |
IChangeSet.getAuthor()
Returns a contributor handle identifying the contributor whom is considered the
author of the change set.
|
IContributorHandle |
IBaseline.getCreator()
Returns the contributor which created this baseline.
|
IContributorHandle |
IBaselineSet.getCreator()
Returns the contributor which created this baseline set.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IChangeSetPropertiesSearchCriteria.getAuthor()
Returns the author matched changesets must be authored by.
|
IContributorHandle |
ILockSearchCriteria.getContributor() |
IContributorHandle |
IVersionableLock.getContributor()
Get the contributor who locked the versionable item.
|
IContributorHandle |
IChangeSetSearchCriteria.getSuspendedBy()
Returns the contributor that the matched changesets must be suspended by.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<IContributorHandle> |
IBaselineSearchCriteria.getFilterByCreatorOptional() |
| Modifier and Type | Method and Description |
|---|---|
IVersionableLock |
IVersionableLock.IFactory.createInstance(IContributorHandle contributor,
IVersionableHandle versionable) |
void |
IChangeSetPropertiesSearchCriteria.setAuthor(IContributorHandle value)
Set the author matched changesets must be authored by.
|
void |
ILockSearchCriteria.setContributor(IContributorHandle contributor) |
void |
IChangeSetSearchCriteria.setSuspendedBy(IContributorHandle contributor)
Set the contributor that the matched changesets must be suspended by.
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle[] |
IAuditableCommonProcess.getContributorsWithRole(IContributorHandle[] contributors,
IProcessArea processArea,
java.lang.String[] roleIds,
org.eclipse.core.runtime.IProgressMonitor monitor)
Given a set of contributors, returns all contributors that have at least one of the given roles assigned relative to the
given area.
|
IContributorHandle |
IAuditableCommon.getUser() |
| Modifier and Type | Method and Description |
|---|---|
java.util.List<IQueryDescriptor> |
IQueryCommon.findPersonalQueries(IProjectAreaHandle projectAreaHandle,
IContributorHandle creator,
java.lang.String queryType,
ItemProfile<IQueryDescriptor> profile,
org.eclipse.core.runtime.IProgressMonitor monitor) |
java.util.List<IQueryDescriptor> |
IQueryCommon.findQuickPlannerPersonalQueries(IProjectAreaHandle projectAreaHandle,
IContributorHandle creator,
java.lang.String queryType,
ItemProfile<IQueryDescriptor> profile,
org.eclipse.core.runtime.IProgressMonitor monitor)
Deprecated.
- Quick planner apis are deprecated and are not supposed to be used.
|
java.util.List<IRole> |
IAuditableCommonProcess.getContributorRoles(IContributorHandle contributor,
IProcessArea processArea,
org.eclipse.core.runtime.IProgressMonitor monitor) |
IContributorHandle[] |
IAuditableCommonProcess.getContributorsWithRole(IContributorHandle[] contributors,
IProcessArea processArea,
java.lang.String[] roleIds,
org.eclipse.core.runtime.IProgressMonitor monitor)
Given a set of contributors, returns all contributors that have at least one of the given roles assigned relative to the
given area.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.Collection<IContributorHandle> |
UnassignedVariable.evaluate(IEvaluationContext context,
org.eclipse.core.runtime.IProgressMonitor monitor) |
java.util.Collection<IContributorHandle> |
CurrentUserVariable.evaluate(IEvaluationContext context,
org.eclipse.core.runtime.IProgressMonitor monitor) |
java.util.Collection<IContributorHandle> |
AnyoneVariable.evaluate(IEvaluationContext context,
org.eclipse.core.runtime.IProgressMonitor monitor) |
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IApproval.getApprover()
Returns the contributor that is asked for approval.
|
IContributorHandle |
IStateTransition.getChangedBy() |
IContributorHandle[] |
ISubscriptions.getContents()
Returns the list of subscribers.
|
IContributorHandle |
IWorkItem.getCreator()
Returns the creator.
|
IContributorHandle |
ITimeSheetEntry.getCreator() |
IContributorHandle |
IComment.getCreator() |
IContributorHandle |
IAttachment.getCreator() |
IContributorHandle |
IWorkItem.getOwner()
Returns the owner.
|
IContributorHandle |
IWorkItem.getResolver()
Returns the resolver.
|
IContributorHandle |
IESignatureRecord.getSigner()
Returns the signer
|
| Modifier and Type | Method and Description |
|---|---|
void |
ISubscriptions.add(IContributorHandle contributor)
Adds the given contributor to the subscribers.
|
boolean |
IApprovals.contains(IApprovalDescriptor descriptor,
IContributorHandle approver)
Returns
true iff there already is an approval with the
given descriptor and contributor. |
boolean |
ISubscriptions.contains(IContributorHandle contributor)
Returns
true iff the given contributor is part of
the subscribers. |
IApproval |
IApprovals.createApproval(IApprovalDescriptor descriptor,
IContributorHandle approver)
Create an approval for the given descriptor and approver.
|
IComment |
IComments.createComment(IContributorHandle creator,
com.ibm.team.foundation.common.text.XMLString content)
Creates a new comment from the given arguments.
|
void |
ISubscriptions.remove(IContributorHandle contributor)
Removes the given contributor from the subscribers.
|
void |
IWorkItem.setCreator(IContributorHandle value)
Internal
|
void |
ITimeSheetEntry.setCreator(IContributorHandle contrib) |
void |
IWorkItem.setOwner(IContributorHandle value)
Sets the owner.
|
void |
IESignatureRecord.setSigner(IContributorHandle signer)
Set the signer to the given
|
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IQueryDescriptor.getCreator() |
| Modifier and Type | Method and Description |
|---|---|
IContributorHandle |
IWorkItemTemplateHandle.getOwner() |