import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Pulls data from CloudStack API
 *
 * @return JSON string
 * @throws IOException
 */
private String pullData() throws IOException {
    logger.trace("Starting to pull data from provided URL");

    // create connection
    Client client = new Client(Protocol.HTTP);
    ClientResource cr = new ClientResource(url);
    Request req = cr.getRequest();

    // now header
    Series<Header> headerValue = new Series<Header>(Header.class);
    req.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, headerValue);
    headerValue.add("Accept", "application/json");
    headerValue.add("Content-Type", "application/json");

    // fire it up
    cr.get(MediaType.APPLICATION_JSON);
    Representation output = cr.getResponseEntity();

    logger.trace("Successfully pulled data from provided URL");

    // and return response data
    return output.getText();
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * The request headers
 * 
 * @return The request headers
 */
@SuppressWarnings("unchecked")
public Series<Header> getRequestHeaders()
{
	if( requestHeaders == null )
	{
		ConcurrentMap<String, Object> attributes = getRequest().getAttributes();
		requestHeaders = (Series<Header>) attributes.get( HeaderConstants.ATTRIBUTE_HEADERS );
		if( requestHeaders == null )
		{
			requestHeaders = new Series<Header>( Header.class );
			attributes.put( HeaderConstants.ATTRIBUTE_HEADERS, requestHeaders );
		}
	}
	return requestHeaders;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * The extra response headers
 * 
 * @return The extra response headers
 */
@SuppressWarnings("unchecked")
public Series<Header> getResponseHeaders()
{
	if( responseHeaders == null )
	{
		ConcurrentMap<String, Object> attributes = getResponse().getAttributes();
		responseHeaders = (Series<Header>) attributes.get( HeaderConstants.ATTRIBUTE_HEADERS );
		if( responseHeaders == null )
		{
			responseHeaders = new Series<Header>( Header.class );
			attributes.put( HeaderConstants.ATTRIBUTE_HEADERS, responseHeaders );
		}
	}
	return responseHeaders;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Creates a collection of link headers based on response headers.
 * 
 * @param headers
 *        The response headers
 * @return A collection of link headers
 */
public static Collection<LinkHeader> wrapLinkHeaders( Series<Header> headers )
{
	Collection<LinkHeader> linkHeaders = new ArrayList<LinkHeader>();
	for( Header header : headers )
	{
		if( header.getName().equalsIgnoreCase( HEADER_LINK ) )
		{
			try
			{
				LinkHeader linkHeader = new LinkHeaderReader( header.getValue(), headers ).readValue();
				linkHeaders.add( linkHeader );
			}
			catch( IOException x )
			{
				Context.getCurrentLogger().log( Level.WARNING, "Error during " + HEADER_LINK + " header parsing. Header: " + header.getValue(), x );
			}
		}
	}
	return linkHeaders;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Removes all link headers with the specified reference from the response
 * headers.
 * 
 * @param headers
 *        The response headers
 * @param reference
 *        The reference
 * @return True if removed
 */
public static boolean removeLinkHeaders( Series<Header> headers, String reference )
{
	boolean removed = false;
	for( Iterator<Header> i = headers.iterator(); i.hasNext(); )
	{
		Header header = i.next();
		if( header.getName().equalsIgnoreCase( HEADER_LINK ) )
		{
			try
			{
				LinkHeader linkHeader = new LinkHeaderReader( header.getValue(), headers ).readValueOnlyReference();
				if( linkHeader.getReference().equals( reference ) )
				{
					i.remove();
					removed = true;
				}
			}
			catch( IOException x )
			{
				Context.getCurrentLogger().log( Level.WARNING, "Error during " + HEADER_LINK + " header parsing. Header: " + header.getValue(), x );
			}
		}
	}
	return removed;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Gets the response headers, making sure to create them if they don't
 * exist.
 * 
 * @param response
 *        The response
 * @return The headers
 */
public static Series<Header> getResponseHeaders( Response response )
{
	ConcurrentMap<String, Object> attributes = response.getAttributes();
	@SuppressWarnings("unchecked")
	Series<Header> headers = (Series<Header>) attributes.get( HeaderConstants.ATTRIBUTE_HEADERS );
	if( headers == null )
	{
		headers = new Series<Header>( Header.class );
		@SuppressWarnings("unchecked")
		Series<Header> existing = (Series<Header>) attributes.putIfAbsent( HeaderConstants.ATTRIBUTE_HEADERS, headers );
		if( existing != null )
			headers = existing;
	}
	return headers;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Configures REST HTTP Request Forms.
 * 
 * @param message the HTTP message to setup
 * @return the message configured HTTP headers.
 */
@SuppressWarnings("unchecked")
public static Series<Header> configureRestForm(Message message) {
    ConcurrentMap<String, Object> attrs = message.getAttributes();
    Series<Header> headers = (Series<Header>) attrs.get(HEADERS_KEY);

    if (headers == null) {
        headers = new Series<Header>(Header.class);
        Series<Header> prev = (Series<Header>) attrs.putIfAbsent(HEADERS_KEY, headers);

        if (prev != null)
            headers = prev;
    }

    headers.add(ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW_ALL_FROM_ORIGIN);
    message.getCacheDirectives().add(CacheDirective.noCache());
    return headers;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Pull data from provided URL
 * @param url
 * @return output string or empty string
 */
private String pullData(String url){
    try {
        ClientResource cr = new ClientResource(url);
        Request req = cr.getRequest();

        // now header
        Series<Header> headerValue = new Series<Header>(Header.class);
        req.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, headerValue);
        headerValue.add("Accept", "application/json");
        headerValue.add("Content-Type", "application/json");

        // fire it up
        cr.get(MediaType.APPLICATION_JSON);
        Representation output = cr.getResponseEntity();

        // return null or received text
        return (output == null) ? "" : output.getText();
    } catch (Exception ignored) {
        return "";
    }
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Pull data from provided URL
 * @param url
 * @return output string or empty string
 */
private String pullData(String url) throws IOException {
    Client client = new Client(Protocol.HTTP);
    ClientResource cr = new ClientResource(url);
    Request req = cr.getRequest();

    // now header
    Series<Header> headerValue = new Series<Header>(Header.class);
    req.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, headerValue);
    headerValue.add("Accept", "application/json");
    headerValue.add("Content-Type", "application/json");

    // fire it up
    cr.get(MediaType.APPLICATION_JSON);
    Representation output = cr.getResponseEntity();

    // return null or received text
    return (output == null) ? "" : output.getText();
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Pull data from provided URL
 *
 * @param url
 * @return output string
 */
private String pullData(String url) throws IOException {
    Client client = new Client(Protocol.HTTP);
    ClientResource cr = new ClientResource(url);
    Request req = cr.getRequest();

    // now header
    Series<Header> headerValue = new Series<Header>(Header.class);
    req.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, headerValue);
    headerValue.add("Accept", "application/json");
    headerValue.add("Content-Type", "application/json");

    // fire it up
    cr.get(MediaType.APPLICATION_JSON);
    Representation output = cr.getResponseEntity();

    // and return response data
    return output.getText();
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Returns the modifiable list of response headers.
 * 
 * @return The modifiable list of response headers.
 */
@Override
public Series<Header> getResponseHeaders()
{
	final Series<Header> result = super.getResponseHeaders();

	if( !responseHeadersAdded )
	{
		final HttpResponse httpResponse = getHttpResponse();
		if( httpResponse != null )
		{
			final HttpFields headers = httpResponse.getHeaders();
			if( headers != null )
			{
				for( HttpField header : headers )
					result.add( header.getName(), header.getValue() );
			}
		}

		responseHeadersAdded = true;
	}

	return result;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Returns the last persisted list of meters
 * <p>
 * Pseudo Code<br>
 * 1. Receive the request for the list of meters<br>
 * 2. Query the DB to get the list<br>
 * 3. Return the list of meters
 *
 * @return Representation A JSON response containing the list of meters
 */
@Get
public String getMeterList() {
    counter.increment(endpoint);

    Gson gson = new Gson();

    try {
        String meterUrl = Loader.getSettings().getKeyStoneSettings().getCeilometerURL()+"/meters";
        ClientResource meterResource = new ClientResource(meterUrl);

        Series<Header> requestHeaders =
                (Series<Header>) meterResource.getRequestAttributes().get("org.restlet.http.headers");

        if (requestHeaders == null) {
            requestHeaders = new Series<Header>(Header.class);
            meterResource.getRequestAttributes().put("org.restlet.http.headers", requestHeaders);
        }

        KeystoneClient keystoneClient = new KeystoneClient();
        logger.trace("Attempting to create the token");
        String subjectToken = keystoneClient.generateToken();

        requestHeaders.set("X-Auth-Token", subjectToken);

        OpenstackMeter[] meters = gson.fromJson(meterResource.get(MediaType.APPLICATION_JSON).getText(), OpenstackMeter[].class);

        return gson.toJson(meters);

    } catch (Exception e) {
        logger.error("Error while getting the Keystone Meters: "+e.getMessage());
        return null;
    }
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Whether the client asked for do-not-track.
 * 
 * @return Whether the client asked for do-not-track
 */
public boolean getDoNotTrack()
{
	if( doNotTrack == null )
	{
		Header dnt = getRequestHeaders().getFirst( "DNT" );
		doNotTrack = ( dnt != null ) && dnt.getValue().equals( "1" );
	}
	return doNotTrack;
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Adds the caching debug headers if enabled.
 * 
 * @param cacheEntry
 *        The cache entry
 * @param cacheKey
 *        The cache key
 * @param executable
 *        The executable
 * @param suffix
 *        The optional attribute suffix
 */
public void addDebugHeaders( String event, CacheEntry cacheEntry, String cacheKey, Executable executable, String suffix )
{
	if( !attributes.isDebugCaching() )
		return;

	Series<Header> headers = cacheEntry.getHeaders();

	if( headers == null )
		headers = new Series<Header>( Header.class );
	else
	{
		// Copy headers
		Series<Header> newHeaders = new Series<Header>( Header.class );
		for( Header header : headers )
			newHeaders.add( header );
		headers = newHeaders;
	}

	SimpleDateFormat format = new SimpleDateFormat( CACHE_EXPIRATION_HEADER_FORMAT );
	format.setTimeZone( TimeZone.getTimeZone( "GMT" ) );

	// This will override headers set by includes
	headers.set( CACHE_HEADER, event );
	headers.set( CACHE_KEY_HEADER, cacheKey );
	headers.set( CACHE_EXPIRATION_HEADER, format.format( cacheEntry.getExpirationDate() ) );

	headers.removeAll( CACHE_TAGS_HEADER );
	Set<String> cacheTags = getTags( executable, suffix, false );
	if( cacheTags != null )
	{
		for( String cacheTag : cacheTags )
			headers.add( CACHE_TAGS_HEADER, cacheTag );
	}

	// Apply headers
	resource.getResponse().getAttributes().put( HeaderConstants.ATTRIBUTE_HEADERS, headers );
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * TODO: this can't be good! needs proper escaping!
 * 
 * @param headers
 *        The headers
 * @return The serialized headers
 */
private static String serializeHeaders( Series<Header> headers )
{
	StringBuilder s = new StringBuilder();
	for( Iterator<Header> i = headers.iterator(); i.hasNext(); )
	{
		Header header = i.next();
		s.append( header.getName() );
		s.append( "=" );
		s.append( header.getValue() );
		if( i.hasNext() )
			s.append( '&' );
	}
	return s.toString();
}
 

import org.restlet.data.Header; //导入依赖的package包/类
@Override
protected void afterHandle( Request request, Response response )
{
	Series<Header> headers = RestletUtil.getResponseHeaders( response );
	if( allowOrigin != null )
		response.setAccessControlAllowOrigin( allowOrigin );
	if( !allowMethods.isEmpty() )
		response.setAccessControlAllowMethods( allowMethods );
	if( !allowHeaders.isEmpty() )
		response.setAccessControlAllowHeaders( allowHeaders );
	if( maxAge > 0 )
		headers.add( new Header( MAX_AGE_HEADER, Integer.toString( maxAge ) ) );
}
 

import org.restlet.data.Header; //导入依赖的package包/类
/**
 * Saves the link header to the response headers.
 */
public void save()
{
	remove();
	Header header = new Header( HEADER_LINK, toHeaderValue() );
	headers.add( header );
}
 

import org.restlet.data.Header; //导入依赖的package包/类
public void addHeaders(ClientResource client) {
    Series<Header> reqHeaders = (Series<Header>)
    client.getRequestAttributes().get(HeaderConstants.ATTRIBUTE_HEADERS);
    if (reqHeaders == null) {
        reqHeaders = new Series(Header.class);
        client.getRequestAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, reqHeaders);
    }
 
    Iterator it = headers.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry pairs = (Map.Entry)it.next();
        reqHeaders.add(new Header(pairs.getKey().toString(), pairs.getValue().toString() ));
    }
    
}
 

import org.restlet.data.Header; //导入依赖的package包/类
private void headersToFile(Series headers, String fileName) throws IOException {
    Map map = new HashMap();
    for (Object header1 : headers) {
        Header header = (Header) header1;
        map.put(header.getName(), header.getValue());
    }
    headersToFile(map, fileName);
}
 

import org.restlet.data.Header; //导入依赖的package包/类
private void compareHeaders(Series headers, InputStream inputStream) throws IOException {
    Map map = new HashMap();
    for (Object header1 : headers) {
        Header header = (Header) header1;
        map.put(header.getName(), header.getValue());
    }
    compareHeaders(map, inputStream);
}