trafficserver-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bri...@apache.org
Subject [2/5] initial atscppapi commit
Date Fri, 18 Oct 2013 21:51:09 GMT
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/ClientRequest.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/ClientRequest.h b/lib/atscppapi/src/include/atscppapi/ClientRequest.h
new file mode 100644
index 0000000..2da61c5
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/ClientRequest.h
@@ -0,0 +1,59 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file ClientRequest.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_CLIENTREQUEST_H_
+#define ATSCPPAPI_CLIENTREQUEST_H_
+
+#include <atscppapi/Request.h>
+
+namespace atscppapi {
+
+struct ClientRequestState;
+
+/**
+ * @brief Encapsulates a client request. A client request is different from a
+ * server request as it has two URLs - the pristine URL sent by the client 
+ * and a remapped URL created by the server.
+ */
+class ClientRequest : public Request {
+public:
+  /**
+   * @private
+   */
+  ClientRequest(void *raw_txn, void *hdr_buf, void *hdr_loc);
+
+  /**
+   * Returns the pristine (pre-remap) client request URL 
+   *
+   * @return Url Reference to non-mutable pristine URL.
+   */
+  const Url &getPristineUrl() const;
+
+  ~ClientRequest();
+private:
+  ClientRequestState *state_;
+};
+
+}
+
+#endif /* ATSCPPAPI_CLIENTREQUEST_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/GlobalPlugin.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/GlobalPlugin.h b/lib/atscppapi/src/include/atscppapi/GlobalPlugin.h
new file mode 100644
index 0000000..cff431d
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/GlobalPlugin.h
@@ -0,0 +1,90 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file GlobalPlugin.h
+ * @brief Contains the interface used in creating Global plugins.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_GLOBALPLUGIN_H_
+#define ATSCPPAPI_GLOBALPLUGIN_H_
+
+#include <atscppapi/Plugin.h>
+
+namespace atscppapi {
+
+class GlobalPluginState;
+
+/**
+ * @brief The interface used when creating a GlobalPlugin.
+ *
+ * A GlobalPlugin is a Plugin that will fire for a given hook on all Transactions.
+ * In otherwords, a GlobalPlugin is not tied to a specific plugin, a Transaction
+ * specific plugin would be a TransactionPlugin.
+ *
+ * Depending on the
+ * type of hook you choose to build you will implement one or more callback methods.
+ * Here is a simple example of a GlobalPlugin:
+ *
+ * \code
+ * class GlobalHookPlugin : public GlobalPlugin {
+ * public:
+ *  GlobalHookPlugin() {
+ *   registerHook(HOOK_READ_REQUEST_HEADERS_PRE_REMAP);
+ *  }
+ *  virtual void handleReadRequestHeadersPreRemap(Transaction &transaction) {
+ *    std::cout << "Hello from handleReadRequesHeadersPreRemap!" << std::endl;
+ *    transaction.resume();
+ *  }
+ * };
+ * \endcode
+ * @see Plugin
+ */
+class GlobalPlugin : public Plugin {
+public:
+  /**
+   * registerHook is the mechanism used to attach a global hook.
+   *
+   * \note Whenever you register a hook you must have the appropriate callback definied in your GlobalPlugin
+   *  see HookType and Plugin for the correspond HookTypes and callback methods. If you fail to implement the
+   *  callback, a default implmentation will be used that will only resume the Transaction.
+   *
+   * @param HookType the type of hook you wish to register
+   * @see HookType
+   * @see Plugin
+   */
+  void registerHook(Plugin::HookType);
+  virtual ~GlobalPlugin();
+protected:
+  /**
+   * Constructor.
+   *
+   * @param ignore_internal_transactions When true, all hooks registered by this plugin are ignored
+   *                                     for internal transactions (internal transactions are created
+   *                                     when other plugins create requests). Defaults to false.
+   */
+  GlobalPlugin(bool ignore_internal_transactions = false);
+private:
+  GlobalPluginState *state_; /**< Internal state tied to a GlobalPlugin */
+};
+
+} /* atscppapi */
+
+
+#endif /* ATSCPPAPI_GLOBALPLUGIN_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/GzipDeflateTransformation.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/GzipDeflateTransformation.h b/lib/atscppapi/src/include/atscppapi/GzipDeflateTransformation.h
new file mode 100644
index 0000000..a7e6923
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/GzipDeflateTransformation.h
@@ -0,0 +1,91 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file GzipDeflateTransformation.h
+ * @brief Gzip Deflate Transformation can be used to compress content.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_GZIPDEFLATETRANSFORMATION_H_
+#define ATSCPPAPI_GZIPDEFLATETRANSFORMATION_H_
+
+#include <string>
+#include "atscppapi/TransformationPlugin.h"
+
+namespace atscppapi {
+
+namespace transformations {
+
+/**
+ * Internal state for Deflate Transformations
+ * @private
+ */
+class GzipDeflateTransformationState;
+
+/**
+ * @brief A TransformationPlugin to easily add gzip deflate to your TransformationPlugin chain.
+ *
+ * The GzipDeflateTransformation is a helper transformation that can be used
+ * to easily compress content. For a full example of GzipDeflateTransformation
+ * and GzipInflateTransformation see examples/gzip_transformation/.
+ *
+ * @note GzipDeflateTransformation DOES NOT set Content-Encoding headers, it is the
+ * users responsibility to set any applicable headers.
+ *
+ * @see GzipInflateTransformation
+ */
+class GzipDeflateTransformation : public TransformationPlugin {
+public:
+  /**
+   * A full example of how to use GzipDeflateTransformation and GzipInflateTransformation is available
+   * in examples/gzip_tranformation/
+   *
+   * @param transaction As with any TransformationPlugin you must pass in the transaction
+   * @param type because the GzipDeflateTransformation can be used with both requests and responses
+   *  you must specify the Type.
+   *
+   * @see TransformationPlugin::Type
+   */
+  GzipDeflateTransformation(Transaction &transaction, TransformationPlugin::Type type);
+
+  /**
+   * Any TransformationPlugin must implement consume(), this method will take content
+   * from the transformation chain and gzip compress it.
+   *
+   * @param data the input data to compress
+   */
+  void consume(const std::string &data);
+
+  /**
+   * Any TransformationPlugin must implement handleInputComplete(), this method will
+   * finalize the gzip compression and flush any remaining data and the epilouge.
+   */
+  void handleInputComplete();
+
+  virtual ~GzipDeflateTransformation();
+private:
+  GzipDeflateTransformationState *state_; /** Internal state for Gzip Deflate Transformations */
+};
+
+}
+
+}
+
+
+#endif /* ATSCPPAPI_GZIPDEFLATETRANSFORMATION_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/GzipInflateTransformation.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/GzipInflateTransformation.h b/lib/atscppapi/src/include/atscppapi/GzipInflateTransformation.h
new file mode 100644
index 0000000..412af91
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/GzipInflateTransformation.h
@@ -0,0 +1,92 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file GzipInflateTransformation.h
+ * @brief Gzip Inflate Transformation can be used to decompress gzipped content.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_GZIPINFLATETRANSFORMATION_H_
+#define ATSCPPAPI_GZIPINFLATETRANSFORMATION_H_
+
+#include <string>
+#include "atscppapi/TransformationPlugin.h"
+
+namespace atscppapi {
+
+namespace transformations {
+
+/**
+ * Internal state for Inflate Transformations
+ * @private
+ */
+class GzipInflateTransformationState;
+
+/**
+ * @brief A TransformationPlugin to easily add gzip inflate to your TransformationPlugin chain.
+ *
+ * The GzipInflateTransformation is a helper transformation that can be used
+ * to easily decompress gzipped content. For a full example of GzipInflateTransformation
+ * and GzipDeflateTransformation see examples/gzip_transformation/.
+ *
+ * @note GzipDeflateTransformation DOES NOT set or check Content-Encoding headers, it is the
+ * users responsibility to set any applicable headers and check that the content is acctually
+ * gzipped by checking the Content-Encoding header before creating a GzipInflateTransformation,
+ * see examples/gzip_transformation/ for a full example.
+ *
+ * @see GzipDeflateTransformation
+ */
+class GzipInflateTransformation : public TransformationPlugin {
+public:
+  /**
+   * A full example of how to use GzipInflateTransformation and GzipDeflateTransformation is available
+   * in examples/gzip_tranformation/
+   *
+   * @param transaction As with any TransformationPlugin you must pass in the transaction
+   * @param type because the GzipInflateTransformation can be used with both requests and responses
+   *  you must specify the Type.
+   *
+   * @see TransformationPlugin::Type
+   */
+  GzipInflateTransformation(Transaction &transaction, TransformationPlugin::Type type);
+
+  /**
+   * Any TransformationPlugin must implement consume(), this method will take content
+   * from the transformation chain and gzip decompress it.
+   *
+   * @param data the input data to decompress
+   */
+  void consume(const std::string &);
+
+  /**
+   * Any TransformationPlugin must implement handleInputComplete(), this method will
+   * finalize the gzip decompression.
+   */
+  void handleInputComplete();
+
+  virtual ~GzipInflateTransformation();
+private:
+  GzipInflateTransformationState *state_; /** Internal state for Gzip Deflate Transformations */
+};
+
+} /* transformations */
+
+} /* atscppapi */
+
+#endif /* ATSCPPAPI_GZIPINFLATETRANSFORMATION_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Headers.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Headers.h b/lib/atscppapi/src/include/atscppapi/Headers.h
new file mode 100644
index 0000000..af02707
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Headers.h
@@ -0,0 +1,246 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file Headers.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_HEADERS_H_
+#define ATSCPPAPI_HEADERS_H_
+
+#include <map>
+#include <list>
+#include <atscppapi/CaseInsensitiveStringComparator.h>
+#include <atscppapi/noncopyable.h>
+
+namespace atscppapi {
+
+struct HeadersState;
+class Request;
+class ClientRequest;
+class Response;
+
+/**
+ * @brief Encapsulates the headers portion of a request or response.
+ */
+class Headers: noncopyable {
+public:
+  
+  enum Type { TYPE_REQUEST, TYPE_RESPONSE };
+
+  Headers(Type type = TYPE_REQUEST);
+
+  Type getType() const;
+
+  typedef std::map<std::string, std::list<std::string>, CaseInsensitiveStringComparator> NameValuesMap;
+
+  typedef NameValuesMap::size_type size_type;
+  typedef NameValuesMap::const_iterator const_iterator;
+  typedef NameValuesMap::const_reverse_iterator const_reverse_iterator;
+
+  /**
+   * @return Iterator to first header.
+   */
+  const_iterator begin() const;
+
+  /**
+   * @return Iterator to end of headers.
+   */
+  const_iterator end() const;
+
+  /**
+   * @return Iterator to last header.
+   */
+  const_reverse_iterator rbegin() const;
+
+  /**
+   * @return Iterator to "reverse end"
+   */
+  const_reverse_iterator rend() const;
+
+  /**
+   * @param key Name of header
+   * @return Iterator to header if exists, else end()
+   */
+  const_iterator find(const std::string &key) const;
+
+  /**
+   * @param key Name of header
+   * @return 1 if header exists, 0 if not. 
+   */
+  size_type count(const std::string &key) const;
+
+  /**
+   * Erases header with given name.
+   *
+   * @param key Name of header
+   * @return 1 if header was erased, 0 if not. 
+   */
+  size_type erase(const std::string &key);
+
+  /**
+   * Sets the given header and values. If a header of same name existed, that is
+   * deleted. Else header is appended.
+   * 
+   * @param pair Contains the name and list of values.
+   *
+   * @return Iterator to header set. 
+   */
+  const_iterator set(const std::pair<std::string, std::list<std::string> > &pair);
+
+  /**
+   * Sets the given header and values. If a header of same name existed, that is
+   * deleted. Else header is appended.
+   *
+   * @param key Name of header
+   * @param val List of values
+   * 
+   * @return Iterator to header set. 
+   */
+  const_iterator set(const std::string &key, const std::list<std::string> &val);
+
+  /**
+   * Sets the given header and values. If a header of same name existed, that is
+   * deleted. Else header is appended.
+   *
+   * @param key Name of header
+   * @param val Value
+   * 
+   * @return Iterator to header set. 
+   */
+  const_iterator set(const std::string &key, const std::string &val);
+
+  /**
+   * Appends a new header. If a header of the same name exists, value(s) is tacked
+   * on that the end of current value(s). 
+   * 
+   * @param pair Contains the name and list of values.
+   *
+   * @return Iterator to header appended. 
+   */
+  const_iterator append(const std::pair<std::string, std::list<std::string> > &pair);
+
+  /**
+   * Appends a new header. If a header of the same name exists, value(s) is tacked
+   * on that the end of current value(s). 
+   * 
+   * @param key Name of header
+   * @param val List of values
+   * 
+   * @return Iterator to header appended. 
+   */
+  const_iterator append(const std::string &key, const std::list<std::string> &val);
+
+  /**
+   * Appends a new header. If a header of the same name exists, value(s) is tacked
+   * on that the end of current value(s). 
+   * 
+   * @param key Name of header
+   * @param val Value
+   * 
+   * @return Iterator to header appended. 
+   */
+  const_iterator append(const std::string &key, const std::string &val);
+
+  /**
+   * Joins provided list of values with delimiter (defaulting to ',').
+   *
+   * @return Composite string
+   */
+  static std::string getJoinedValues(const std::list<std::string> &values, char delimiter = ',');
+
+  /**
+   * Joins values of provided header with delimiter (defaulting to ',').
+   *
+   * @return Composite string if header exists, else empty strings.
+   */
+  std::string getJoinedValues(const std::string &key, char value_delimiter = ',');
+
+  /**
+   * @return True if there are no headers.
+   */
+  bool empty() const;
+
+  /**
+   * @return Largest possible size of underlying map.
+   */
+  size_type max_size() const;
+
+  /**
+   * @return Number of headers currently stored.
+   */
+  size_type size() const;
+
+  typedef std::map<std::string, std::list<std::string> > RequestCookieMap;
+
+  /**
+   * @return Cookies in the "Cookie" headers of a request object.
+   */
+  const RequestCookieMap &getRequestCookies() const;
+
+  struct ResponseCookie {
+    std::string name_;
+    std::string value_;
+    std::string comment_;
+    std::string domain_;
+    int max_age_;
+    std::string path_;
+    bool secure_;
+    int version_;
+    ResponseCookie() : max_age_(0), secure_(false), version_(0) { };
+  };
+
+  /**
+   * @return Cookies in the "Set-Cookie" headers of a response object.
+   */
+  const std::list<ResponseCookie> &getResponseCookies() const;
+
+  /** Adds a request cookie */
+  bool addCookie(const std::string &name, const std::string &value);
+
+  /** Adds a response cookie */
+  bool addCookie(const ResponseCookie &response_cookie);
+  
+  /** Sets, i.e., clears current value and adds new value, of a request cookie */
+  bool setCookie(const std::string &name, const std::string &value);
+
+  /** Sets, i.e., clears current value and adds new value, of a response cookie */
+  bool setCookie(const ResponseCookie &response_cookie);
+
+  /** Deletes a cookie */
+  bool deleteCookie(const std::string &name);
+
+  ~Headers();
+private:
+  HeadersState *state_;
+  bool checkAndInitHeaders() const;
+  void init(void *hdr_buf, void *hdr_loc);
+  void initDetached();
+  void setType(Type type);
+  void updateRequestCookieHeaderFromMap();
+  const_iterator doBasicAppend(const std::pair<std::string, std::list<std::string> > &pair);
+  size_type doBasicErase(const std::string &key);
+  friend class Request;
+  friend class ClientRequest;
+  friend class Response;
+};
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/HttpMethod.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/HttpMethod.h b/lib/atscppapi/src/include/atscppapi/HttpMethod.h
new file mode 100644
index 0000000..c07c673
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/HttpMethod.h
@@ -0,0 +1,58 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file HttpMethod.h
+ * @brief Contains an enumeration and printable strings for Http Methods.
+ */
+#pragma once
+#ifndef ATSCPPAPI_HTTP_METHOD_H_
+#define ATSCPPAPI_HTTP_METHOD_H_
+
+#include <string>
+
+namespace atscppapi {
+
+/**
+ * An enumeration of all available Http Methods.
+ */
+enum HttpMethod {
+  HTTP_METHOD_UNKNOWN = 0,
+  HTTP_METHOD_GET,
+  HTTP_METHOD_POST,
+  HTTP_METHOD_HEAD,
+  HTTP_METHOD_CONNECT,
+  HTTP_METHOD_DELETE,
+  HTTP_METHOD_ICP_QUERY,
+  HTTP_METHOD_OPTIONS,
+  HTTP_METHOD_PURGE,
+  HTTP_METHOD_PUT,
+  HTTP_METHOD_TRACE
+};
+
+/**
+ * An array of printable strings representing of the HttpMethod
+ * \code
+ * cout << HTTP_METHOD_STRINGS[HTTP_METHOD_GET] << endl;
+ * \endcode
+ */
+extern const std::string HTTP_METHOD_STRINGS[];
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/HttpStatus.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/HttpStatus.h b/lib/atscppapi/src/include/atscppapi/HttpStatus.h
new file mode 100644
index 0000000..e1ba25b
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/HttpStatus.h
@@ -0,0 +1,104 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file HttpStatus.h
+ * @brief Contains an enumeration and printable strings for Http Status codes.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_HTTP_STATUS_H_
+#define ATSCPPAPI_HTTP_STATUS_H_
+
+#include <string>
+
+namespace atscppapi {
+
+/**
+ * An enumeration of all available Http Status Codes.
+ */
+enum HttpStatus
+{
+  HTTP_STATUS_UNKNOWN = 0,
+
+  HTTP_STATUS_CONTINUE = 100,
+  HTTP_STATUS_SWITCHING_PROTOCOL = 101,
+
+  HTTP_STATUS_OK = 200,
+  HTTP_STATUS_CREATED = 201,
+  HTTP_STATUS_ACCEPTED = 202,
+  HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,
+  HTTP_STATUS_NO_CONTENT = 204,
+  HTTP_STATUS_RESET_CONTENT = 205,
+  HTTP_STATUS_PARTIAL_CONTENT = 206,
+  HTTP_STATUS_MULTI_STATUS = 207,
+  HTTP_STATUS_ALREADY_REPORTED = 208,
+  HTTP_STATUS_IM_USED = 211,
+
+  HTTP_STATUS_MULTIPLE_CHOICES = 300,
+  HTTP_STATUS_MOVED_PERMANENTLY = 301,
+  HTTP_STATUS_MOVED_TEMPORARILY = 302,
+  HTTP_STATUS_SEE_OTHER = 303,
+  HTTP_STATUS_NOT_MODIFIED = 304,
+  HTTP_STATUS_USE_PROXY = 305,
+  HTTP_STATUS_TEMPORARY_REDIRECT = 307,
+  HTTP_STATUS_PERMANENT_REDIRECT = 308,
+
+  HTTP_STATUS_BAD_REQUEST = 400,
+  HTTP_STATUS_UNAUTHORIZED = 401,
+  HTTP_STATUS_PAYMENT_REQUIRED = 402,
+  HTTP_STATUS_FORBIDDEN = 403,
+  HTTP_STATUS_NOT_FOUND = 404,
+  HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
+  HTTP_STATUS_NOT_ACCEPTABLE = 406,
+  HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
+  HTTP_STATUS_REQUEST_TIMEOUT = 408,
+  HTTP_STATUS_CONFLICT = 409,
+  HTTP_STATUS_GONE = 410,
+  HTTP_STATUS_LENGTH_REQUIRED = 411,
+  HTTP_STATUS_PRECONDITION_FAILED = 412,
+  HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,
+  HTTP_STATUS_REQUEST_URI_TOO_LONG = 414,
+  HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
+  HTTP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+  HTTP_STATUS_EXPECTATION_FAILED = 417,
+  HTTP_STATUS_UNPROCESSABLE_ENTITY = 422,
+  HTTP_STATUS_LOCKED = 423,
+  HTTP_STATUS_FAILED_DEPENDENCY = 424,
+  HTTP_STATUS_UPGRADE_REQUIRED = 426,
+  HTTP_STATUS_PRECONDITION_REQUIRED = 428,
+  HTTP_STATUS_TOO_MANY_REQUESTS = 429,
+  HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+
+  HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
+  HTTP_STATUS_NOT_IMPLEMENTED = 501,
+  HTTP_STATUS_BAD_GATEWAY = 502,
+  HTTP_STATUS_SERVICE_UNAVAILABLE = 503,
+  HTTP_STATUS_GATEWAY_TIMEOUT = 504,
+  HTTP_STATUS_HTTPVER_NOT_SUPPORTED = 505,
+  HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506,
+  HTTP_STATUS_INSUFFICIENT_STORAGE = 507,
+  HTTP_STATUS_LOOP_DETECTED = 508,
+  HTTP_STATUS_NOT_EXTENDED = 510,
+  HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511
+
+};
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/HttpVersion.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/HttpVersion.h b/lib/atscppapi/src/include/atscppapi/HttpVersion.h
new file mode 100644
index 0000000..fdbd639
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/HttpVersion.h
@@ -0,0 +1,52 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file HttpVersion.h
+ * @brief Contains an enumeration and printable strings for Http Versions.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_HTTP_VERSION_H_
+#define ATSCPPAPI_HTTP_VERSION_H_
+
+#include <string>
+
+namespace atscppapi {
+
+/**
+ * An enumeration of all available Http Versions.
+ */
+enum HttpVersion {
+  HTTP_VERSION_UNKNOWN = 0,
+  HTTP_VERSION_0_9,
+  HTTP_VERSION_1_0,
+  HTTP_VERSION_1_1,
+};
+
+/**
+ * An array of printable strings representing of the HttpVersion
+ * \code
+ * cout << HTTP_VERSION_STRINGS[HTTP_VERSION_1_1] << endl;
+ * \endcode
+ */
+extern const std::string HTTP_VERSION_STRINGS[];
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Logger.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Logger.h b/lib/atscppapi/src/include/atscppapi/Logger.h
new file mode 100644
index 0000000..ef6e3a6
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Logger.h
@@ -0,0 +1,268 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file Logger.h
+ * @brief Helpers and Classes related to Logging
+ *
+ * @warning Log rolling doesn't work correctly in 3.2.x see:
+ *   https://issues.apache.org/jira/browse/TS-1813
+ *   Apply the patch in TS-1813 to correct log rolling in 3.2.x
+ *
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_LOGGER_H_
+#define ATSCPPAPI_LOGGER_H_
+
+#include <string>
+#include <atscppapi/noncopyable.h>
+
+#if !defined(ATSCPPAPI_PRINTFLIKE)
+#if defined(__GNUC__) || defined(__clang__)
+/**
+ * This macro will tell GCC that the function takes printf like arugments
+ * this is helpful because it can produce better warning and error messages
+ * when a user doesn't use the methods correctly.
+ *
+ * @private
+ */
+#define ATSCPPAPI_PRINTFLIKE(fmt, arg) __attribute__((format(printf, fmt, arg)))
+#else
+#define ATSCPPAPI_PRINTFLIKE(fmt, arg)
+#endif
+#endif
+
+/**
+ * A helper macro for Logger objects that allows you to easily add a debug level message
+ * which will include file, line, and function name with the message. It's very easy to use:
+ * \code
+ *  // Suppose you have already created a Logger named logger:
+ *  LOG_DEBUG(logger, "This is a test DEBUG message: %s", "hello");
+ *  // Outputs [file.cc:125, function()] [DEBUG] This is a test DEBUG message: hello.
+ * \endcode
+ */
+#define LOG_DEBUG(log, fmt, ...) \
+  do { \
+    (log).logDebug("[%s:%d, %s()] " fmt, __FILE__, __LINE__, __FUNCTION__, ## __VA_ARGS__); \
+  } while (false)
+
+/**
+ * A helper macro for Logger objects that allows you to easily add a info level message
+ * which will include file, line, and function name with the message. See example in LOG_DEBUG
+ */
+#define LOG_INFO(log, fmt, ...) \
+  do { \
+    (log).logInfo("[%s:%d, %s()] " fmt, __FILE__, __LINE__, __FUNCTION__, ## __VA_ARGS__); \
+  } while (false)
+
+/**
+ * A helper macro for Logger objects that allows you to easily add a error level message
+ * which will include file, line, and function name with the message.  See example in LOG_DEBUG
+ */
+#define LOG_ERROR(log, fmt, ...) \
+  do { \
+    (log).logError("[%s:%d, %s()] " fmt, __FILE__, __LINE__, __FUNCTION__, ## __VA_ARGS__); \
+  } while (false)
+
+/**
+ * We forward declare this because if we didn't we end up writing our
+ * own version to do the vsnprintf just to call TSDebug and have it do
+ * an unncessary vsnprintf.
+ *
+ * @private
+ */
+extern "C" void TSDebug(const char *tag, const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(2,3);
+
+/**
+ * We forward declare this because if we didn't we end up writing our
+ * own version to do the vsnprintf just to call TSError and have it do
+ * an unncessary vsnprintf.
+ *
+ * @private
+ */
+extern "C" void TSError(const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(1,2);
+
+// This is weird, but see the following:
+//   http://stackoverflow.com/questions/5641427/how-to-make-preprocessor-generate-a-string-for-line-keyword
+#define STRINGIFY0(x) #x
+#define STRINGIFY(x) STRINGIFY0(x)
+#define LINE_NO STRINGIFY(__LINE__)
+
+/**
+ * A helper macro to get access to the Diag messages available in traffic server. These can be enabled
+ * via traffic_server -T "tag.*" or since this macro includes the file can you further refine to an
+ * individual file or even a particular line! This can also be enabled via records.config.
+ */
+#define TS_DEBUG(tag, fmt, ...) \
+  do { \
+    TSDebug(tag "." __FILE__ ":" LINE_NO , "[%s()] " fmt, __FUNCTION__, ## __VA_ARGS__); \
+  } while (false)
+
+/**
+ * A helper macro to get access to the error.log messages available in traffic server. This
+ * will also output a DEBUG message visible via traffic_server -T "tag.*", or by enabling the
+ * tag in records.config.
+ */
+#define TS_ERROR(tag, fmt, ...) \
+  do { \
+    TS_DEBUG(tag, "[ERROR] " fmt, ## __VA_ARGS__); \
+    TSError("[%s] [%s:%d, %s()] " fmt, tag, __FILE__, __LINE__, __FUNCTION__, ## __VA_ARGS__); \
+  } while (false)
+
+namespace atscppapi {
+
+class LoggerState;
+
+/**
+ * @brief Create log files that are automatically rolled and cleaned up as space is required.
+ *
+ * Log files created using the Logger class will be placed in the same directory as
+ * other log files, that directory is specified in records.config. All of the logging
+ * configuration such as max space available for all logs includes any logs created
+ * using the Logger class.
+ *
+ * Loggers are very easy to use and a full example is available in examples/logger_example/,
+ * a simple example is:
+ * \code
+ * // See Logger::init() for an explanation of the init() parameters.
+ * log.init("logger_example", true, true, Logger::LOG_LEVEL_DEBUG);
+ * // You have two ways to log to a logger, you can log directly on the object itself:
+ * log.logInfo("Hello World from: %s", argv[0]);
+ * // Alternatively you can take advantage of the super helper macros for logging
+ * // that will include the file, function, and line number automatically as part
+ * // of the log message:
+ * LOG_INFO(log, "Hello World with more info from: %s", argv[0]);
+ * \endcode
+ *
+ * @warning Log rolling doesn't work correctly in 3.2.x see:
+ *   https://issues.apache.org/jira/browse/TS-1813
+ *   Apply the patch in TS-1813 to correct log rolling in 3.2.x
+ *
+ */
+class Logger : noncopyable {
+public:
+
+  /**
+   * The available log levels
+   */
+  enum LogLevel {
+    LOG_LEVEL_NO_LOG = 128, /**< This log level is used to disable all logging */
+    LOG_LEVEL_DEBUG = 1, /**< This log level is used for DEBUG level logging (DEBUG + INFO + ERROR) */
+    LOG_LEVEL_INFO = 2, /**< This log level is used for INFO level logging (INFO + ERROR) */
+    LOG_LEVEL_ERROR = 4 /**< This log level is used for ERROR level logging (ERROR ONLY) */
+  };
+
+  Logger();
+  ~Logger();
+
+  /**
+   * You must always init() a Logger before you begin logging. If you do not call init() nothing will
+   * happen.
+   *
+   * @param file The name of the file to create in the logging directory, if you do not specify an extension .log will be used.
+   * @param add_timestamp Prepend a timestamp to the log lines, the default value is true.
+   * @param rename_file If a file already exists by the same name it will attempt to rename using a scheme that appends .1, .2, and so on,
+   *   the default value for this argument is true.
+   * @param level the default log level to use when creating the logger, this is set to LOG_LEVEL_INFO by default.
+   * @param rolling_enabled if set to true this will enable log rolling on a periodic basis, this is enabled by default.
+   * @param rolling_interval_seconds how frequently to roll the longs in seconds, this is set to 3600 by default (one hour).
+   * @return returns true if the logger was successfully created and initialized.
+   * @see LogLevel
+   */
+  bool init(const std::string &file, bool add_timestamp = true, bool rename_file = true,
+      LogLevel level = LOG_LEVEL_INFO, bool rolling_enabled = true, int rolling_interval_seconds = 3600);
+
+  /**
+   * Allows you to change the rolling interval in seconds
+   * @param seconds the number of seconds between rolls
+   */
+  void setRollingIntervalSeconds(int seconds);
+
+  /**
+   * @return the number of seconds between log rolls.
+   */
+  int getRollingIntervalSeconds() const;
+
+  /**
+   * Enables or disables log rolling
+   * @param enabled true to enable log rolling, false to disable it.
+   */
+  void setRollingEnabled(bool enabled);
+
+  /**
+   * @return A boolean value which represents whether rolling is enabled or disabled.
+   */
+  bool isRollingEnabled() const;
+
+  /**
+   * Change the log level
+   *
+   * @param level the new log level to use
+   * @see LogLevel
+   */
+  void setLogLevel(Logger::LogLevel level);
+
+  /**
+   * @return The current log level.
+   * @see LogLevel
+   */
+  Logger::LogLevel getLogLevel() const;
+
+  /**
+   * This method allows you to flush any log lines that might have been buffered.
+   * @warning This method can cause serious performance degredation so you should only
+   * use it when absolutely necessary.
+   */
+  void flush();
+
+  /**
+   * This method writes a DEBUG level message to the log file, the LOG_DEBUG
+   * macro in Logger.h should be used in favor of these when possible because it
+   * will produce a much more rich debug message.
+   *
+   * Sample usage:
+   * \code
+   * log.logDebug("Hello you are %d years old", 27);
+   * \endcode
+   */
+  void logDebug(const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(2,3);
+
+  /**
+   * This method writes an INFO level message to the log file, the LOG_INFO
+   * macro in Logger.h should be used in favor of these when possible because it
+   * will produce a much more rich info message.
+   */
+  void logInfo(const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(2,3);
+
+  /**
+   * This method writes an ERROR level message to the log file, the LOG_ERROR
+   * macro in Logger.h should be used in favor of these when possible because it
+   * will produce a much more rich error message.
+   */
+  void logError(const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(2,3);
+private:
+  LoggerState *state_; /**< Internal state for the Logger */
+};
+
+} /* atscppapi */
+
+
+
+
+#endif /* ATSCPPAPI_LOGGER_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Mutex.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Mutex.h b/lib/atscppapi/src/include/atscppapi/Mutex.h
new file mode 100644
index 0000000..6044477
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Mutex.h
@@ -0,0 +1,250 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file Mutex.h
+ * @brief Contains Mutex related classes for creating a Mutex and locking a Mutex in a specific scope.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_MUTEX_H_
+#define ATSCPPAPI_MUTEX_H_
+
+#include <pthread.h>
+#include <atscppapi/noncopyable.h>
+#include <atscppapi/shared_ptr.h>
+
+namespace atscppapi {
+
+/**
+ * @brief A mutex is mutual exclusion: a blocking lock.
+ *
+ * The Mutex class uses pthreads for its implmentation.
+ *
+ * @see ScopedMutexLock
+ * @see ScopedMutexTryLock
+ * @see ScopedSharedMutexLock
+ * @see ScopedSharedMutexTryLock
+ */
+class Mutex: noncopyable {
+public:
+
+  /**
+   * The available types of Mutexes.
+   */
+  enum Type {
+    TYPE_NORMAL = 0, /**< This type of Mutex will deadlock if locked by a thread already holding the lock */
+    TYPE_RECURSIVE, /**< This type of Mutex will allow a thread holding the lock to lock it again; however, it must be unlocked the same number of times */
+    TYPE_ERROR_CHECK /**< This type of Mutex will return errno = EDEADLCK if a thread would deadlock by taking the lock after it already holds it */
+  };
+
+  /**
+   * Create a mutex
+   *
+   * @param type The Type of Mutex to create, the default is TYPE_NORMAL.
+   * @see Type
+   */
+  Mutex(Type type = TYPE_NORMAL) {
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+
+    switch(type) {
+    case TYPE_RECURSIVE:
+     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+     break;
+    case TYPE_ERROR_CHECK:
+     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+     break;
+    case TYPE_NORMAL:
+    default:
+     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+     break;
+    }
+
+    pthread_mutex_init(&mutex, &attr);
+  }
+
+  ~Mutex() {
+    pthread_mutex_destroy(&mutex);
+  }
+
+  /**
+   * Try to take the lock, this call will NOT block if the mutex cannot be taken.
+   * @return Returns true if the lock was taken, false if it was not. This call obviously will not block.
+   */
+  bool tryLock() {
+    return !pthread_mutex_trylock(&mutex);
+  }
+
+  /**
+   * Block until the lock is taken, when this call returns the thread will be holding the lock.
+   */
+  void lock() {
+    pthread_mutex_lock(&mutex);
+  }
+
+  /**
+   * Unlock the lock, this call is nonblocking.
+   */
+  void unlock() {
+    pthread_mutex_unlock(&mutex);
+  }
+private:
+  pthread_mutex_t mutex; /**< Internal mutex identifier */
+};
+
+/**
+ * @brief Take a Mutex reference and lock inside a scope and unlock when the scope is exited.
+ *
+ * This is an RAII implementation which will lock a mutex at the start of the
+ * scope and unlock it when the scope is exited.
+ *
+ * @see Mutex
+ */
+class ScopedMutexLock: noncopyable {
+public:
+  /**
+   * Create the scoped mutex lock, once this object is constructed the lock will be held by the thread.
+   * @param mutex a reference to a Mutex.
+   */
+  explicit ScopedMutexLock(Mutex &mutex) :
+      mutex_(mutex) {
+    mutex_.lock();
+  }
+
+  /**
+   * Unlock the mutex.
+   */
+  ~ScopedMutexLock() {
+    mutex_.unlock();
+  }
+private:
+  Mutex &mutex_;
+};
+
+/**
+ * @brief Take a shared_ptr to a Mutex and lock inside a scope and unlock when the scope is exited.
+ *
+ * This is an RAII implementation which will lock a mutex at the start of the
+ * scope and unlock it when the scope is exited.
+ *
+ * @see Mutex
+ */
+class ScopedSharedMutexLock: noncopyable {
+public:
+  /**
+   * Create the scoped mutex lock, once this object is constructed the lock will be held by the thread.
+   * @param mutex a shared pointer to a Mutex.
+   */
+  explicit ScopedSharedMutexLock(shared_ptr<Mutex> mutex) :
+      mutex_(mutex) {
+    mutex_->lock();
+  }
+
+  /**
+   * Unlock the mutex.
+   */
+  ~ScopedSharedMutexLock() {
+    mutex_->unlock();
+  }
+private:
+  shared_ptr<Mutex> mutex_;
+};
+
+/**
+ * @brief Take a Mutex reference and try to lock inside a scope and unlock when the scope is exited (if the lock was taken).
+ *
+ * This is an RAII implementation which will lock a mutex at the start of the
+ * scope and unlock it when the scope is exited if the lock was taken.
+ *
+ * @see Mutex
+ */
+class ScopedMutexTryLock: noncopyable {
+public:
+  /**
+   * Try to create the scoped mutex lock, if you should check hasLock() to determine if this object was successfully able to take the lock.
+   * @param mutex a shared pointer to a Mutex.
+   */
+  explicit ScopedMutexTryLock(Mutex &mutex) :
+      mutex_(mutex), has_lock_(false) {
+    has_lock_ = mutex_.tryLock();
+  }
+
+  /**
+   * Unlock the mutex (if we hold the lock)
+   */
+  ~ScopedMutexTryLock() {
+    if (has_lock_) {
+      mutex_.unlock();
+    }
+  }
+
+  /**
+   * @return True if the lock was taken, False if it was not taken.
+   */
+  bool hasLock() {
+    return has_lock_;
+  }
+private:
+  Mutex &mutex_;
+  bool has_lock_;
+};
+
+/**
+ * @brief Take a shared_ptr to a Mutex and try to lock inside a scope and unlock when the scope is exited (if the lock was taken).
+ *
+ * This is an RAII implementation which will lock a mutex at the start of the
+ * scope and unlock it when the scope is exited if the lock was taken.
+ *
+ * @see Mutex
+ */
+class ScopedSharedMutexTryLock: noncopyable {
+public:
+  /**
+   * Try to create the scoped mutex lock, if you should check hasLock() to determine if this object was successfully able to take the lock.
+   * @param mutex a shared pointer to a Mutex.
+   */
+  explicit ScopedSharedMutexTryLock(shared_ptr<Mutex> mutex) :
+      mutex_(mutex), has_lock_(false) {
+    has_lock_ = mutex_->tryLock();
+  }
+
+  /**
+   * Unlock the mutex (if we hold the lock)
+   */
+  ~ScopedSharedMutexTryLock() {
+    if (has_lock_) {
+      mutex_->unlock();
+    }
+  }
+
+  /**
+   * @return True if the lock was taken, False if it was not taken.
+   */
+  bool hasLock() {
+    return has_lock_;
+  }
+private:
+  shared_ptr<Mutex> mutex_;
+  bool has_lock_;
+};
+
+} /* atscppapi */
+
+
+#endif /* ATSCPPAPI_MUTEX_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Plugin.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Plugin.h b/lib/atscppapi/src/include/atscppapi/Plugin.h
new file mode 100644
index 0000000..677a3bd
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Plugin.h
@@ -0,0 +1,106 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Plugin.h
+ *
+ * @brief Contains the base interface used in creating Global and Transaciton plugins.
+ * \note This interface can never be implemented directly, it should be implemented
+ *   through extending GlobalPlugin, TransactionPlugin, or TransformationPlugin.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_PLUGIN_H_
+#define ATSCPPAPI_PLUGIN_H_
+
+#include <atscppapi/Transaction.h>
+#include <atscppapi/noncopyable.h>
+
+namespace atscppapi {
+
+/**
+ * @brief The base interface used when creating a Plugin.
+ *
+ * \note This interface can never be implemented directly, it should be implemented
+ *   through extending GlobalPlugin, TransactionPlugin, or TransformationPlugin.
+ *
+ * @see TransactionPlugin
+ * @see GlobalPlugin
+ * @see TransformationPlugin
+ */
+class Plugin: noncopyable {
+public:
+  /**
+   * A enumeration of the available types of Hooks. These are used with GlobalPlugin::registerHook()
+   * and TransactionPlugin::registerHook().
+   */
+  enum HookType {
+    HOOK_READ_REQUEST_HEADERS_PRE_REMAP = 0, /**< This hook will be fired before remap has occured. */
+    HOOK_READ_REQUEST_HEADERS_POST_REMAP, /**< This hook will be fired directly after remap has occured. */
+    HOOK_SEND_REQUEST_HEADERS, /**< This hook will be fired right before request headers are sent to the origin */
+    HOOK_READ_RESPONSE_HEADERS, /**< This hook will be fired right after response headers have been read from the origin */
+    HOOK_SEND_RESPONSE_HEADERS, /**< This hook will be fired right before the response headers are sent to the client */
+    HOOK_OS_DNS /**< This hook will be fired right after the OS DNS lookup */
+  };
+
+  /**
+   * This method must be implemented when you hook HOOK_READ_REQUEST_HEADERS_PRE_REMAP
+   */
+  virtual void handleReadRequestHeadersPreRemap(Transaction &transaction) { transaction.resume(); };
+
+  /**
+   * This method must be implemented when you hook HOOK_READ_REQUEST_HEADERS_POST_REMAP
+   */
+  virtual void handleReadRequestHeadersPostRemap(Transaction &transaction) { transaction.resume(); };
+
+  /**
+   * This method must be implemented when you hook HOOK_SEND_REQUEST_HEADERS
+   */
+  virtual void handleSendRequestHeaders(Transaction &transaction) { transaction.resume(); };
+
+  /**
+   * This method must be implemented when you hook HOOK_READ_RESPONSE_HEADERS
+   */
+  virtual void handleReadResponseHeaders(Transaction &transaction) { transaction.resume(); };
+
+  /**
+   * This method must be implemented when you hook HOOK_SEND_RESPONSE_HEADERS
+   */
+  virtual void handleSendResponseHeaders(Transaction &transaction) { transaction.resume(); };
+
+  /**
+   * This method must be implemented when you hook HOOK_OS_DNS
+   */
+  virtual void handleOsDns(Transaction &transaction) { transaction.resume(); };
+
+  virtual ~Plugin() { };
+protected:
+  /**
+  * \note This interface can never be implemented directly, it should be implemented
+  *   through extending GlobalPlugin, TransactionPlugin, or TransformationPlugin.
+  *
+  * @private
+  */
+  Plugin() { };
+};
+
+/**< Human readable strings for each HookType, you can access them as HOOK_TYPE_STRINGS[HOOK_OS_DNS] for example. */
+extern const std::string HOOK_TYPE_STRINGS[];
+
+} /* atscppapi */
+
+#endif /* ATSCPPAPI_GLOBALPLUGIN_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/PluginInit.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/PluginInit.h b/lib/atscppapi/src/include/atscppapi/PluginInit.h
new file mode 100644
index 0000000..ecd72e4
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/PluginInit.h
@@ -0,0 +1,55 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file PluginInit.h
+ * @brief Provides hooks that plugins have to implement. ATS will invoke these when loading the plugin .so files.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_PLUGININIT_H_
+#define ATSCPPAPI_PLUGININIT_H_
+
+extern "C" {
+
+/** 
+ * Invoked for "general" plugins - listed in plugin.config. The arguments in the
+ * plugin.config line are provided in this invocation.
+ *
+ * @param argc Count of arguments
+ * @param argv Array of pointers pointing to arguments
+ */
+void TSPluginInit(int argc, const char *argv[]);
+
+enum TsReturnCode { TS_ERROR = -1, TS_SUCCESS = 0 };
+
+/** 
+ * Invoked for remap plugins - listed in remap.config. The arguments provided as @pparam
+ * in the remap.config line are provided in this invocation.
+ *
+ * @param argc Count of arguments
+ * @param argv Array of pointers pointing to arguments
+ * @param instance_handle Should be passed to the RemapPlugin constructor
+ * @param errbuf Not used
+ * @param errbuf_size Not used
+ */
+TsReturnCode TSRemapNewInstance(int argc, char *argv[], void **instance_handle, char *errbuf, int errbuf_size);
+
+}
+
+
+#endif /* ATSCPPAPI_PLUGININIT_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/RemapPlugin.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/RemapPlugin.h b/lib/atscppapi/src/include/atscppapi/RemapPlugin.h
new file mode 100644
index 0000000..2a80291
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/RemapPlugin.h
@@ -0,0 +1,69 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file RemapPlugin.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_REMAP_PLUGIN_H_
+#define ATSCPPAPI_REMAP_PLUGIN_H_
+
+#include "atscppapi/Transaction.h"
+#include "atscppapi/Url.h"
+
+namespace atscppapi {
+
+/** 
+ * @brief Base class that remap plugins should extend.
+ */
+class RemapPlugin {
+public:
+  /**
+   * Constructor
+   * 
+   * @param instance_handle The instance_handle argument received in TSRemapInit() should be passed here.
+   */
+  RemapPlugin(void **instance_handle);
+
+  enum Result { RESULT_ERROR = 0, RESULT_NO_REMAP, RESULT_DID_REMAP, RESULT_NO_REMAP_STOP,
+                RESULT_DID_REMAP_STOP };
+
+  /** 
+   * Invoked when a request matches the remap.config line - implementation should perform the
+   * remap. The client's URL is in the transaction and that's where it should be modified.
+   * 
+   * @param map_from_url The map from URL specified in the remap.config line.
+   * @param map_to_url The map to URL specified in the remap.config line.
+   * @param transaction Transaction
+   * @param redirect Output argument that should be set to true if the (new) url should be used
+   *                 as a redirect. 
+   *
+   * @return Result of the remap - will dictate futher processing by the system.
+   */
+  virtual Result doRemap(const Url &map_from_url, const Url &map_to_url, Transaction &transaction,
+                         bool &redirect) {
+    return RESULT_NO_REMAP;
+  }
+
+  virtual ~RemapPlugin() { }
+};
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Request.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Request.h b/lib/atscppapi/src/include/atscppapi/Request.h
new file mode 100644
index 0000000..8831725
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Request.h
@@ -0,0 +1,72 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Request.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_REQUEST_H_
+#define ATSCPPAPI_REQUEST_H_
+
+#include <atscppapi/Headers.h>
+#include <atscppapi/HttpVersion.h>
+#include <atscppapi/HttpMethod.h>
+#include <atscppapi/Url.h>
+#include <atscppapi/noncopyable.h>
+
+namespace atscppapi {
+
+class Transaction;
+struct RequestState;
+
+/**
+ * @brief Encapsulates a request.
+ */
+class Request: noncopyable {
+public:
+  Request();
+
+  /**
+   * Constructed with an initial URL.
+   */
+  Request(const std::string &url, HttpMethod method = HTTP_METHOD_GET, HttpVersion version = HTTP_VERSION_1_1); 
+
+  /** @return HTTP method of the request */
+  HttpMethod getMethod() const;
+
+  /** @return URL of the request */
+  Url &getUrl();
+
+  /** @return HTTP version of the request */
+  HttpVersion getVersion() const;
+
+  /** @return Headers of the request */
+  Headers &getHeaders() const;
+
+  ~Request();
+private:
+  Request(void *hdr_buf, void *hdr_loc);
+  RequestState *state_;
+  void init(void *hdr_buf, void *hdr_loc);
+  friend class Transaction;
+  friend class ClientRequest;
+};
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Response.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Response.h b/lib/atscppapi/src/include/atscppapi/Response.h
new file mode 100644
index 0000000..f309bc1
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Response.h
@@ -0,0 +1,71 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Response.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_RESPONSE_H_
+#define ATSCPPAPI_RESPONSE_H_
+
+#include <atscppapi/Headers.h>
+#include <atscppapi/HttpVersion.h>
+#include <atscppapi/HttpStatus.h>
+
+namespace atscppapi {
+
+// forward declarations
+struct ResponseState;
+namespace utils { class internal; }
+
+/**
+ * @brief Encapsulates a response.
+ */
+class Response: noncopyable {
+public:
+  Response();
+
+  /** @return HTTP version of the response */
+  HttpVersion getVersion() const;
+
+  /** @return Status code of the response */
+  HttpStatus getStatusCode() const;
+
+  /** @param New status code to set */
+  void setStatusCode(HttpStatus);
+
+  /** @return Reason phrase of the response */
+  const std::string &getReasonPhrase() const;
+
+  /** @param New reason phrase to set */
+  void setReasonPhrase(const std::string &);
+
+  /** @return Headers of the response */
+  Headers &getHeaders() const;
+
+  ~Response();
+private:
+  ResponseState *state_;
+  void init(void *hdr_buf, void *hdr_loc);
+  friend class Transaction;
+  friend class utils::internal;
+};
+
+}
+
+#endif

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Stat.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Stat.h b/lib/atscppapi/src/include/atscppapi/Stat.h
new file mode 100644
index 0000000..d665d1a
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Stat.h
@@ -0,0 +1,106 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Stat.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_STAT_H_
+#define ATSCPPAPI_STAT_H_
+
+#include <atscppapi/noncopyable.h>
+#include <stdint.h>
+#include <string>
+
+namespace atscppapi {
+
+/**
+ * @brief A Stat is an atomic variable that can be used to store counters, averages, time averages, or summations.
+ *
+ * All stats are exposed through the traffic_line program included with Apache Traffic Server. Additionally,
+ * if you've enabled HttpStats all Stats you define will be displayed there. Stats can be read via
+ * traffic_line -r stat_name.
+ *
+ * Stats are very easy to use, here is a simple example of how you can create a counter and increment its
+ * value:
+ * \code
+ *  Stat stat;
+ *  stat.init("stat_name");
+    stat.inc();
+ * \endcode
+ *
+ * A full example is available in examples/stat_example/.
+ */
+class Stat : noncopyable {
+public:
+  /**
+   * The available Stat types.
+   */
+  enum SyncType {
+    SYNC_SUM = 0, /**< The stat will sum all values from a stat.inc(VAL) */
+    SYNC_COUNT, /**< The stat will count all calls to stat.inc(VAL) */
+    SYNC_AVG, /**< The stat will keep an average after call calls to stat.inc(VAL) */
+    SYNC_TIMEAVG /**< The stat will keep a time average of all calls to stat.inc(VAL) */
+  };
+
+  Stat();
+  ~Stat();
+
+  /**
+   * You must initialize your Stat with a call to this init() method.
+   *
+   * @param name The string name of the stat, this will be visbible via traffic_line -r, or through http stats.
+   * @param type The SyncType of the Stat, this decides how TrafficServer will treat your inputs. The default
+   *   value is SYNC_COUNT.
+   * @param persistent This determines if your Stats will persist, the default value is false.
+   * @return True if the stat was successfully created and false otherwise.
+   *
+   * @see SyncType
+   */
+  bool init(std::string name, Stat::SyncType type = SYNC_COUNT, bool persistent = false);
+
+  /**
+   * This method allows you to increment a stat by a certain amount.
+   * @param amount the amount to increment the stat by the default value is 1.
+   */
+  void increment(int64_t amount = 1);
+
+  /**
+   * This method allows you to decrement a stat by a certain amount.
+   * @param amount the amount to decrement the stat by the default value is 1.
+   */
+  void decrement(int64_t amount = 1);
+
+  /**
+   * This method returns the current value of the stat.
+   * @return The value of the stat.
+   */
+  int64_t get() const;
+
+  /** This method sets the value of the stat.
+   * @param value the value to set the stat to.
+   */
+  void set(int64_t value);
+private:
+  int stat_id_; /**< The internal stat ID */
+};
+
+} /* atscppapi */
+
+
+#endif /* ATSCPPAPI_STAT_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Transaction.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Transaction.h b/lib/atscppapi/src/include/atscppapi/Transaction.h
new file mode 100644
index 0000000..3610d1b
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Transaction.h
@@ -0,0 +1,314 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Transaction.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_TRANSACTION_H_
+#define ATSCPPAPI_TRANSACTION_H_
+
+#include <sys/socket.h>
+#include <stdint.h>
+#include <list>
+#include "atscppapi/Request.h"
+#include "atscppapi/shared_ptr.h"
+#include "atscppapi/ClientRequest.h"
+#include "atscppapi/Response.h"
+
+namespace atscppapi {
+
+// forward declarations
+class TransactionPlugin;
+class TransactionState;
+namespace utils { class internal; }
+
+/**
+ * @brief Transactions are the object containing all the state related to a HTTP Transaction
+ *
+ * @warning Transactions should never be directly created by the user, they will always be automatically
+ * created and destroyed as they are needed. Transactions should never be saved beyond the
+ * scope of the function in which they are delivered otherwise undefined behaviour will result.
+ */
+class Transaction: noncopyable {
+public:
+  /**
+   * @brief ContextValues are a mechanism to share data between plugins using the atscppapi.
+   *
+   * Any data can be shared so long as it extends ContextValue, a simple example might
+   * be:
+   *
+   * \code
+   *     struct mydata : ContextValue {
+   *       int id_;
+   *       string foo_;
+   *       mydata(int id, string foo) : id_(id), foo_(foo) { }
+   *     }
+   *
+   *     Transaction.setContextValue("some-key", shared_ptr(new mydata(12, "hello")));
+   *
+   *     // From another plugin you'll have access to this contextual data:
+   *     shared_ptr<Transaction.getContextValue("some-key")
+   *
+   * \endcode
+   *
+   * Because getContextValue() and setContextValue()
+   * take shared pointers you dont have to worry about the cleanup as that will happen automatically so long
+   * as you dont have shared_ptrs that cannot go out of scope.
+   */
+  class ContextValue {
+  public:
+    virtual ~ContextValue() { }
+  };
+
+  ~Transaction();
+
+  /**
+   * Context Values are a way to share data between plugins, the key is always a string
+   * and the value can be a shared_ptr to any type that extends ContextValue.
+   * @param key the key to search for.
+   * @return Shared pointer that is correctly initialized if the
+   *         value existed. It should be checked with .get() != NULL before use.
+   */
+  shared_ptr<ContextValue> getContextValue(const std::string &key);
+
+  /**
+   * Context Values are a way to share data between plugins, the key is always a string
+   * and the value can be a shared_ptr to any type that extends ContextValue.
+   * @param key the key to insert.
+   * @param value a shared pointer to a class that extends ContextValue.
+   */
+  void setContextValue(const std::string &key, shared_ptr<ContextValue> value);
+
+  /**
+   * Causes the Transaction to continue on to other states in the HTTP state machine
+   * If you do not call resume() on a Transaction it will remain in that state until
+   * it's advanced out by a call to resume() or error().
+   */
+  void resume();
+
+  /**
+   * Causes the Transaction to advance to the error state in the HTTP state machine.
+   * @see error(const std::string &)
+   */
+  void error();
+
+  /**
+   * Causes the Transaction to advance to the error state in the HTTP state machine with
+   * a specific error message displayed. This is functionally equivalent to the following:
+   *
+   * \code
+   * setErrorBody(content);
+   * error();
+   * \endcode
+   *
+   * @param content the error page body.
+   */
+  void error(const std::string &content);
+
+  /**
+   * Sets the error body page but this method does not advance the state machine to the error state.
+   * To do that you must explicitally call error().
+   *
+   * @param content the error page content.
+   */
+  void setErrorBody(const std::string &content);
+
+  /**
+   * Get the clients address
+   * @return The sockaddr structure representing the client's address
+   * @see atscppapi::utils::getIpString() in atscppapi/utils.h
+   * @see atscppapi::utils::getPort() in atscppapi/utils.h
+   * @see atscppapi::utils::getIpPortString in atscppapi/utils.h
+   */
+  const sockaddr *getClientAddress() const;
+
+  /**
+   * Get the incoming address
+   * @return The sockaddr structure representing the incoming address
+   * @see atscppapi::utils::getIpString() in atscppapi/utils.h
+   * @see atscppapi::utils::getPort() in atscppapi/utils.h
+   * @see atscppapi::utils::getIpPortString in atscppapi/utils.h
+   */
+  const sockaddr *getIncomingAddress() const;
+
+  /**
+   * Get the server address
+   * @return The sockaddr structure representing the server's address
+   * @see atscppapi::utils::getIpString() in atscppapi/utils.h
+   * @see atscppapi::utils::getPort() in atscppapi/utils.h
+   * @see atscppapi::utils::getIpPortString in atscppapi/utils.h
+   */
+  const sockaddr *getServerAddress() const;
+
+  /**
+   * Get the next hop address
+   * @return The sockaddr structure representing the next hop's address
+   * @see atscppapi::utils::getIpString() in atscppapi/utils.h
+   * @see atscppapi::utils::getPort() in atscppapi/utils.h
+   * @see atscppapi::utils::getIpPortString in atscppapi/utils.h
+   */
+  const sockaddr *getNextHopAddress() const;
+
+
+  /**
+   * Set the incoming port on the Transaction
+   *
+   * @param port is the port to set as the incoming port on the transaction
+   */
+  bool setIncomingPort(uint16_t port);
+
+  /**
+   * Sets the server address on the Transaction to a populated sockaddr *
+   *
+   * @param sockaddr* the sockaddr structure populated as the server address.
+   */
+  bool setServerAddress(const sockaddr *);
+
+  /**
+   * Returns a boolean value if the request is an internal request.
+   * A request is an internal request if it originates from within traffic server.
+   * An example would be using TSFetchUrl (or the atscppapi equivalent of AsyncHttpFetch)
+   * to make another request along with the original request. The secondary request
+   * originated within traffic server and is an internal request.
+   *
+   * @return boolean value specifying if the request was an internal request.
+   */
+  bool isInternalRequest() const;
+
+  /**
+   * Returns the ClientRequest object for the incoming request from the client.
+   *
+   * @return ClientRequest object that can be used to manipulate the incoming request from the client.
+   */
+  ClientRequest &getClientRequest();
+
+  /**
+   * Returns a Request object which is the request from Traffic Server to the origin server.
+   *
+   * @return Request object that can be used to manipulate the outgoing request to the origin server.
+   */
+  Request &getServerRequest();
+
+  /**
+   * Returns a Response object which is the response coming from the origin server
+   *
+   * @return Response object that can be used to manipulate the incoming response from the origin server.
+   */
+  Response &getServerResponse();
+
+  /**
+   * Returns a Response object which is the response going to the client
+   *
+   * @return Response object that can be used to manipulate the outgoing response from the client.
+   */
+  Response &getClientResponse();
+
+  /**
+   * Returns the Effective URL for this transaction taking into account host.
+   */
+  std::string getEffectiveUrl();
+
+  /**
+   * Sets the url used by the ATS cache for a specific transaction.
+   * @param url is the url to use in the cache.
+   */
+  bool setCacheUrl(const std::string &);
+
+  /**
+   * The available types of timeouts you can set on a Transaction.
+   */
+  enum TimeoutType {
+    TIMEOUT_DNS = 0, /**< Timeout on DNS */
+    TIMEOUT_CONNECT, /**< Timeout on Connect */
+    TIMEOUT_NO_ACTIVITY, /**< Timeout on No Activity */
+    TIMEOUT_ACTIVE /**< Timeout with Activity */
+  };
+
+  /**
+   * Allows you to set various types of timeouts on a Transaction
+   *
+   * @param type The type of timeout
+   * @param time_ms The timeout time in milliseconds
+   * @see TimeoutType
+   */
+  void setTimeout(TimeoutType type, int time_ms);
+
+  /**
+   * Returns the TSHttpTxn related to the current Transaction
+   *
+   * @return a void * which can be cast back to a TSHttpTxn.
+   */
+  void *getAtsHandle() const;
+
+  /**
+   * Adds a TransactionPlugin to the current Transaction. This effectively transfers ownership and the
+   * Transaction is now responsible for cleaning it up.
+   *
+   * @param TransactionPlugin* the TransactionPlugin that will be now bound to the current Transaction.
+   */
+  void addPlugin(TransactionPlugin *);
+
+private:
+  TransactionState *state_; //!< The internal TransactionState object tied to the current Transaction
+  friend class TransactionPlugin; //!< TransactionPlugin is a friend so it can call addPlugin()
+  friend class TransformationPlugin; //!< TransformationPlugin is a friend so it can call addPlugin()
+
+  /**
+   * @private
+   *
+   * @param raw_txn a void pointer that represents a TSHttpTxn
+   */
+  Transaction(void *);
+
+  /**
+   * Used to initialize the Request object for the Server.
+   *
+   * @private
+   */
+  void initServerRequest();
+
+  /**
+   * Used to initialize the Response object for the Server.
+   *
+   * @private
+   */
+  void initServerResponse();
+
+  /**
+   * Used to initialize the Response object for the Client.
+   *
+   * @private
+   */
+  void initClientResponse();
+
+  /**
+   * Returns a list of TransactionPlugin pointers bound to the current Transaction
+   *
+   * @private
+   *
+   * @return a std::list<TransactionPlugin *> which represents all TransactionPlugin bound to the current Transaction.
+   */
+  const std::list<TransactionPlugin *> &getPlugins() const;
+
+  friend class utils::internal;
+};
+
+} /* atscppapi */
+
+#endif /* ATSCPPAPI_TRANSACTION_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/TransactionPlugin.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/TransactionPlugin.h b/lib/atscppapi/src/include/atscppapi/TransactionPlugin.h
new file mode 100644
index 0000000..d473827
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/TransactionPlugin.h
@@ -0,0 +1,113 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file TransactionPlugin.h
+ * @brief Contains the interface used in creating Transaciton plugins.
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_TRANSACTIONPLUGIN_H_
+#define ATSCPPAPI_TRANSACTIONPLUGIN_H_
+
+#include <atscppapi/Plugin.h>
+#include <atscppapi/Transaction.h>
+#include <atscppapi/shared_ptr.h>
+#include <atscppapi/Mutex.h>
+
+namespace atscppapi {
+
+namespace utils {
+ class internal;
+} /* utils */
+
+/**
+ * @private
+ */
+class TransactionPluginState;
+
+/**
+ * @brief The interface used when creating a TransactionPlugin.
+ *
+ * A Transaction Plugin is a plugin that will fire only for the specific Transaction it
+ * was bound to. When you create a TransactionPlugin you call the parent constructor with
+ * the associated Transaction and it will become automatically bound. This means that your
+ * TransactionPlugin will automatically be destroyed when the Transaction dies.
+ *
+ * Implications of this are that you can easily add Transaction scoped storage by adding
+ * a member to a TransactionPlugin since the destructor will be called of your TransactionPlugin
+ * any cleanup that needs to happen can happen in your destructor as you normally would.
+ *
+ * You must always be sure to implement the appropriate callback for the type of hook you register.
+ *
+ * \code
+ * // For a more detailed example see examples/transactionhook/
+ * class TransactionHookPlugin : publicTransactionPlugin {
+ * public:
+ *   TransactionHookPlugin(Transaction &transaction) : TransactionPlugin(transaction) {
+ *     char_ptr_ = new char[100]; // Transaction scoped storage
+ *     registerHook(HOOK_SEND_RESPONSE_HEADERS);
+ *   }
+ *   virtual ~TransactionHookPlugin() {
+ *     delete[] char_ptr_; // cleanup
+ *   }
+ *   void handleSendResponseHeaders(Transaction &transaction) {
+ *     transaction.resume();
+ *   }
+ * private:
+ *   char *char_ptr_;
+ * };
+ * \endcode
+ *
+ * @see Plugin
+ * @see HookType
+ */
+class TransactionPlugin : public Plugin {
+public:
+  /**
+   * registerHook is the mechanism used to attach a transaction hook.
+   *
+   * \note Whenever you register a hook you must have the appropriate callback definied in your TransactionPlugin
+   *  see HookType and Plugin for the correspond HookTypes and callback methods. If you fail to implement the
+   *  callback, a default implmentation will be used that will only resume the Transaction.
+   *
+   * @param HookType the type of hook you wish to register
+   * @see HookType
+   * @see Plugin
+   */
+  void registerHook(Plugin::HookType hook_type);
+  virtual ~TransactionPlugin();
+protected:
+  TransactionPlugin(Transaction &transaction);
+
+  /**
+   * This method will return a shared_ptr to a Mutex that can be used for AsyncProvider and AsyncReceiver operations.
+   *
+   * If another thread wanted to stop this transaction from dispatching an event it could be passed
+   * this mutex and it would be able to lock it and prevent another thread from dispatching back into this
+   * TransactionPlugin.
+   */
+  shared_ptr<Mutex> getMutex();
+private:
+  TransactionPluginState *state_; /**< The internal state for a TransactionPlugin */
+  friend class utils::internal;
+};
+
+} /* atscppapi */
+
+
+#endif /* ATSCPPAPI_TRANSACTIONPLUGIN_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/TransformationPlugin.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/TransformationPlugin.h b/lib/atscppapi/src/include/atscppapi/TransformationPlugin.h
new file mode 100644
index 0000000..c4df942
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/TransformationPlugin.h
@@ -0,0 +1,129 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+/**
+ * @file TransformationPlugin.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_TRANSFORMATIONPLUGIN_H_
+#define ATSCPPAPI_TRANSFORMATIONPLUGIN_H_
+
+#include <string>
+#include <atscppapi/Transaction.h>
+#include <atscppapi/TransactionPlugin.h>
+
+namespace atscppapi {
+
+class TransformationPluginState;
+
+/**
+ * @brief The interface used when you wish to transform Request or Response body content.
+ *
+ * Transformations are deceptively simple, transformations are chained so the output
+ * of one TransformationPlugin becomes the input of another TransformationPlugin. As
+ * data arrives it will fire a consume() and when all the data has been sent
+ * you will receive a handleInputComplete(). Data can be sent to the next TransformationPlugin
+ * in the chain by calling produce() and when the transformation has no data left to send
+ * it will fire a setOutputCompete().
+ *
+ * Since a TransformationPlugin is a type of TransactionPlugin you can call registerHook() and
+ * establish any hook for a Transaction also; however, remember that you must implement
+ * the appropriate callback for any hooks you register.
+ *
+ * A simple example of how to use the TransformationPlugin interface follows, this is an example
+ * of a Response transformation, the avialable options are REQUEST_TRANSFORMATION and RESPONSE_TRANSFORMATION
+ * which are defined in Type.
+ *
+ * This example is a Null Transformation, meaning it will just spit out the content it receives without
+ * actually doing any work on it.
+ *
+ * \code
+ * class NullTransformationPlugin : public TransformationPlugin {
+ * public:
+ *   NullTransformationPlugin(Transaction &transaction)
+ *     : TransformationPlugin(transaction, RESPONSE_TRANSFORMATION) {
+ *     registerHook(HOOK_SEND_RESPONSE_HEADERS);
+ *   }
+ *   void handleSendResponseHeaders(Transaction &transaction) {
+ *     transaction.getClientResponse().getHeaders().set("X-Content-Transformed", "1");
+ *     transaction.resume();
+ *   }
+ *   void consume(const string &data) {
+ *     produce(data);
+ *   }
+ *   void handleInputComplete() {
+ *     setOutputComplete();
+ *   }
+ * };
+ * \endcode
+ *
+ * @see Plugin
+ * @see TransactionPlugin
+ * @see Type
+ * @see HookType
+ */
+class TransformationPlugin : public TransactionPlugin {
+public:
+  /**
+   * The available types of Transformations.
+   */
+  enum Type {
+    REQUEST_TRANSFORMATION = 0, /**< Transform the Request body content */
+    RESPONSE_TRANSFORMATION /**< Transform the Response body content */
+  };
+
+  /**
+   * A method that you must implement when writing a TransformationPlugin, this method will be
+   * fired whenever an upstream TransformationPlugin has produced output.
+   */
+  virtual void consume(const std::string &data) = 0;
+
+  /**
+   * A method that you must implement when writing a TransformationPlugin, this method
+   * will be fired whenever the upstream TransformationPlugin has completed writing data.
+   */
+  virtual void handleInputComplete() = 0;
+
+  virtual ~TransformationPlugin(); /**< Destructor for a TransformationPlugin */
+protected:
+
+  /**
+   * This method is how a TransformationPlugin will produce output for the downstream
+   * transformation plugin, if you need to produce binary data this can still be
+   * done with strings by a call to string::assign() or by constructing a string
+   * with string::string(char *, size_t).
+   */
+  size_t produce(const std::string &);
+
+  /**
+   * This is the method that you must call when you're done producing output for
+   * the downstream TranformationPlugin.
+   */
+  size_t setOutputComplete();
+
+  /** a TransformationPlugin must implement this interface, it cannot be constructed directly */
+  TransformationPlugin(Transaction &transaction, Type type);
+private:
+  TransformationPluginState *state_; /** Internal state for a TransformationPlugin */
+};
+
+} /* atscppapi */
+
+
+#endif /* ATSCPPAPI_TRANSFORMATIONPLUGIN_H_ */

http://git-wip-us.apache.org/repos/asf/trafficserver/blob/7b2ea5f8/lib/atscppapi/src/include/atscppapi/Url.h
----------------------------------------------------------------------
diff --git a/lib/atscppapi/src/include/atscppapi/Url.h b/lib/atscppapi/src/include/atscppapi/Url.h
new file mode 100644
index 0000000..e056d03
--- /dev/null
+++ b/lib/atscppapi/src/include/atscppapi/Url.h
@@ -0,0 +1,149 @@
+/**
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+/**
+ * @file Url.h
+ */
+
+#pragma once
+#ifndef ATSCPPAPI_URL_H_
+#define ATSCPPAPI_URL_H_
+
+#include <string>
+#include <stdint.h>
+#include <atscppapi/noncopyable.h>
+
+namespace atscppapi {
+
+class UrlState;
+
+/**
+ * @brief This class contains all properties of a Url.
+ *
+ * You can use a Url object to get and set any property of a url.
+ *
+ * @warning Url objects should never be constructed by the user.
+ * If a user needs to create an unbound Url then they should create a Request
+ * object using Request::Request(string) which will construct a Url object for them
+ * and it can be retrieved via Request::getUrl(). A full example of this
+ * is available in examples/detachedrequest/.
+ */
+class Url: noncopyable {
+public:
+  /**
+   * @warning Url objects should never be constructed by the user.
+   * If a user needs to create an unbound Url then they should create a Request
+   * object using Request::Request(string) which will construct a Url object for them
+   * and it can be retrieved via Request::getUrl(). A full example of this
+   * is available in examples/detachedrequest/.
+   *
+   * @private
+   */
+  Url();
+
+  /**
+   * @warning Url objects should never be constructed by the user.
+   * If a user needs to create an unbound Url then they should create a Request
+   * object using Request::Request(string) which will construct a Url object for them
+   * and it can be retrieved via Request::getUrl(). A full example of this
+   * is available in examples/detachedrequest/.
+   *
+   * @private
+   */
+  Url(void *hdr_buf, void *url_loc);
+  ~Url();
+
+  /**
+   * @return The full url as a string, such a url might be http://www.linkedin.com/profile/view?id=2941
+   */
+  const std::string &getUrlString() const;
+
+  /**
+   * @return The path only portion of the url, such as /profile/view
+   */
+  const std::string &getPath() const;
+
+  /**
+   * @return The query only portion of the url, which might be id=1234
+   */
+  const std::string &getQuery() const;
+
+  /**
+   * @return The scheme of the url, this will be either http or https.
+   */
+  const std::string &getScheme() const;
+
+  /**
+   * @return The host only of the url, this might be www.linkedin.com
+   */
+  const std::string &getHost() const;
+
+  /**
+   * @return The port only portion of the url, this will likely be 80 or 443.
+   */
+  uint16_t getPort() const;
+
+  /**
+   * Set the path of the url.
+   * @param path the path portion of the url to set, this might be something like /foo/bar
+   */
+  void setPath(const std::string &);
+
+  /**
+   * Set the query param of the url.
+   * @param query the query portion of the url, this might be something like foo=bar&blah=baz.
+   */
+  void setQuery(const std::string &);
+
+  /**
+   * Set the scheme of the url
+   * @param scheme this might be either http or https.
+   */
+  void setScheme(const std::string &);
+
+  /**
+   * Set the host of the url
+   * @param host this might be something such as www.linkedin.com or www.apache.org
+   */
+  void setHost(const std::string &);
+
+  /**
+   * Set the port portion of the url.
+   * @param port this is a uint16_t which represents the port (in host order, there is no need to conver to network order). You
+   * might use a value such as 80 or 8080.
+   */
+  void setPort(const uint16_t);
+
+  /**
+   * This method allows you to reset the url, this will force the Url to fully re-read all cached values.
+   * If this method is used on a Detached Requests' Url object it will completely destroy the values.
+   *
+   * \note This method should rarely be used.
+   */
+  void reset();
+private:
+  bool isInitialized() const;
+  void init(void *hdr_buf, void *url_loc);
+  UrlState *state_;
+  friend class Request;
+  friend class ClientRequest;
+  friend class RemapPlugin;
+};
+
+}
+
+#endif /* ATSCPPAPI_URL_H_ */


Mime
View raw message