Refactoring

Author: jbeemster

src/constants.hpp

@@ -0,0 +1,85 @@
+/*
+Copyright (c) 2016 Snowplow Analytics Ltd. All rights reserved.
+
+This program is licensed to you under the Apache License Version 2.0,
+and you may not use this file except in compliance with the Apache License Version 2.0.
+You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the Apache License Version 2.0 is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+*/
+
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+
+#include <string>
+
+using namespace std;
+
+const string TRACKER_VERSION_LABEL = "cpp-0.1.0";
+
+// post requests
+const string POST_PROTOCOL_VENDOR = "com.snowplowanalytics.snowplow";
+const string POST_PROTOCOL_VERSION = "tp2";
+const string POST_CONTENT_TYPE = "application/json; charset=utf-8";
+
+// get requests
+const string GET_PROTOCOL_PATH = "i";
+
+// schema versions
+const string SCHEMA_PAYLOAD_DATA = "iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4";
+const string SCHEMA_CONTEXTS = "iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-1";
+const string SCHEMA_UNSTRUCT_EVENT = "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0";
+const string SCHEMA_SCREEN_VIEW = "iglu:com.snowplowanalytics.snowplow/screen_view/jsonschema/1-0-0";
+const string SCHEMA_USER_TIMINGS = "iglu:com.snowplowanalytics.snowplow/timing/jsonschema/1-0-0";
+
+// event types
+const string EVENT_STRUCTURED = "se";
+const string EVENT_UNSTRUCTURED = "ue";
+
+const string CONTEXT = "co";
+const string CONTEXT_ENCODED = "cx";
+const string UNSTRUCTURED = "ue_pr";
+const string UNSTRUCTURED_ENCODED = "ue_px";
+
+// general
+const string SCHEMA = "schema";
+const string DATA = "data";
+const string EVENT = "e";
+const string EID = "eid";
+const string TIMESTAMP = "dtm";
+const string SENT_TIMESTAMP = "stm";
+const string TRUE_TIMESTAMP = "ttm";
+const string TRACKER_VERSION = "tv";
+const string APP_ID = "aid";
+const string SP_NAMESPACE = "tna";
+const string PLATFORM = "p";
+
+// subject class
+const string UID = "uid";
+const string RESOLUTION = "res";
+const string VIEWPORT = "vp";
+const string COLOR_DEPTH = "cd";
+const string TIMEZONE = "tz";
+const string LANGUAGE = "lang";
+
+// structured event
+const string SE_CATEGORY = "se_ca";
+const string SE_ACTION = "se_ac";
+const string SE_LABEL = "se_la";
+const string SE_PROPERTY = "se_pr";
+const string SE_VALUE = "se_va";
+
+// screen view
+const string SV_ID = "id";
+const string SV_NAME = "name";
+
+// user timing
+const string UT_CATEGORY = "category";
+const string UT_VARIABLE = "variable";
+const string UT_TIMING = "timing";
+const string UT_LABEL = "label";
+
+#endif

src/cracked_url.cpp

@@ -0,0 +1,100 @@
+/*
+Copyright (c) 2016 Snowplow Analytics Ltd. All rights reserved.
+
+This program is licensed to you under the Apache License Version 2.0,
+and you may not use this file except in compliance with the Apache License Version 2.0.
+You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the Apache License Version 2.0 is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+*/
+
+#include "cracked_url.hpp"
+
+CrackedUrl::CrackedUrl(const string & url) {
+  string cleaned_url = url;
+  if (regex_match(cleaned_url, regex("^https?://.+")) == false) {
+    cleaned_url = string("http://") + url;
+  }
+
+  regex r_host("(https?)://([^\\s]+\\.[^\\s/]+)(/.*)?");
+  regex r_hostname_port("([^:]+):(\\d+)");
+  smatch match;
+
+  if (regex_search(cleaned_url, match, r_host)) {
+    string protocol = match.str(1);
+    string hostname_port = match.str(2);
+    this->path = match.str(3);
+
+    smatch host_match;
+    if (regex_search(hostname_port, host_match, r_hostname_port)) {
+      this->hostname = host_match.str(1);
+      string port = host_match.str(2);
+      this->port = stoi(port);
+      this->use_default_port = false;
+    }
+    else {
+      this->hostname = hostname_port; // it's just a hostname
+      this->port = 0;
+      this->use_default_port = true;
+    }
+
+    this->is_https = protocol == "https";
+    this->error_code = 0;
+    this->is_valid = true;
+  }
+  else {
+    this->error_code = -1;
+    this->is_valid = false;
+  }
+}
+
+string CrackedUrl::get_hostname() {
+  return this->hostname;
+}
+
+string CrackedUrl::get_path() {
+  return this->path;
+}
+
+bool CrackedUrl::get_is_https() {
+  return this->is_https;
+}
+
+bool CrackedUrl::get_is_valid() {
+  return this->is_valid;
+}
+
+int CrackedUrl::get_error_code() {
+  return this->error_code;
+}
+
+unsigned int CrackedUrl::get_port() {
+  return this->port;
+}
+
+bool CrackedUrl::get_use_default_port() {
+  return this->use_default_port;
+}
+
+string CrackedUrl::to_string() {
+  stringstream s;
+
+  if (this->get_is_https()) {
+    s << "https://";
+  } else {
+    s << "http://";
+  }
+
+  s << this->get_hostname();
+
+  if (!this->get_use_default_port()) {
+    s << ":" << std::to_string(this->get_port());
+  }
+
+  s << this->get_path();
+
+  return s.str();
+}

src/cracked_url.hpp

@@ -0,0 +1,45 @@
+/*
+Copyright (c) 2016 Snowplow Analytics Ltd. All rights reserved.
+
+This program is licensed to you under the Apache License Version 2.0,
+and you may not use this file except in compliance with the Apache License Version 2.0.
+You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the Apache License Version 2.0 is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+*/
+
+#ifndef CRACKED_URL_H
+#define CRACKED_URL_H
+
+#include <string>
+#include <sstream>
+#include <regex>
+
+using namespace std;
+
+class CrackedUrl {
+public:
+  CrackedUrl(const string & url);
+  string get_hostname();
+  string get_path();
+  bool get_is_https();
+  bool get_is_valid();
+  int get_error_code();
+  unsigned int get_port();
+  bool get_use_default_port();
+  string to_string();
+
+private:
+  string hostname;
+  string path;
+  bool is_https;
+  bool is_valid;
+  int error_code;
+  unsigned int port;
+  bool use_default_port;
+};
+
+#endif

src/emitter.cpp

@@ -13,25 +13,25 @@ See the Apache License Version 2.0 for the specific language governing permissio
 
 #include "emitter.hpp"
 
-const int post_wrapper_bytes = 88; // "schema":"iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-3","data":[]
+const int post_wrapper_bytes = 88; // "schema":"iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4","data":[]
 const int post_stm_bytes = 22;     // "stm":"1443452851000"
 
-Emitter::Emitter(const string & uri, Strategy strategy, Method method, Protocol protocol, int send_limit, const string & db_name) : m_db(db_name) {
+Emitter::Emitter(const string & uri, Strategy strategy, Method method, Protocol protocol, int send_limit, 
+  int byte_limit_post, int byte_limit_get, const string & db_name) : m_db(db_name), m_url(this->get_collector_url(uri, protocol, method)) {
 
   if (uri == "") {
     throw invalid_argument("FATAL: Emitter URI cannot be empty.");
   }
 
-  this->m_uri = uri;
+  if (!url.get_is_valid()) {
+    throw invalid_argument("FATAL: Emitter URL is not valid - " + url.to_string());
+  }
+
   this->m_strategy = strategy;
   this->m_method = method;
-  this->m_protocol = protocol;
   this->m_send_limit = send_limit;
-
-  this->m_byte_limit_post = 52000;
-  this->m_byte_limit_get = 52000;
-
-  this->m_url = this->get_collector_url();
+  this->m_byte_limit_post = byte_limit_post;
+  this->m_byte_limit_get = byte_limit_get;
 }
 
 Emitter::~Emitter() {
@@ -129,11 +129,11 @@ void Emitter::do_send(list<Storage::EventRow>* event_rows, list<HttpRequestResul
   if (this->m_method == GET) {
     for (list<Storage::EventRow>::iterator it = event_rows->begin(); it != event_rows->end(); ++it) {
       Payload event_payload = it->event;
-      event_payload.add("stm", std::to_string(Utils::get_unix_epoch_ms()));
-      string final_url = this->m_url + "?" + Utils::map_to_query_string(event_payload.get());
+      event_payload.add(SENT_TIMESTAMP, std::to_string(Utils::get_unix_epoch_ms()));
+      string query_string = Utils::map_to_query_string(event_payload.get());
       list<int> row_id = {it->id};
 
-      request_futures.push_back(std::async(HttpClient::http_get, final_url, row_id, (final_url.size() > this->m_byte_limit_get)));
+      request_futures.push_back(std::async(HttpClient::http_get, this->m_url, query_string, row_id, (query_string.size() > this->m_byte_limit_get)));
     }
   } else {
     list<int> row_ids;
@@ -188,19 +188,19 @@ string Emitter::build_post_data_json(list<Payload> payload_list) {
   // Add 'stm' to each payload
   string stm = std::to_string(Utils::get_unix_epoch_ms());
   for (list<Payload>::iterator it = payload_list.begin(); it != payload_list.end(); ++it) {
-    it->add("stm", stm);
+    it->add(SENT_TIMESTAMP, stm);
     data_array.push_back(it->get());
   }
 
   // Build Post event
-  SelfDescribingJson post_envelope("iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4", data_array);
+  SelfDescribingJson post_envelope(SCHEMA_PAYLOAD_DATA, data_array);
   return post_envelope.to_string();
 }
 
-string Emitter::get_collector_url() {
+string Emitter::get_collector_url(const string & uri, Protocol protocol, Method method) {
   stringstream url;
-  url << (this->m_protocol == HTTP ? "http" : "https") << "://" << this->m_uri;
-  url << (this->m_method == GET ? "/i" : "/com.snowplowanalytics.snowplow/tp2");
+  url << (protocol == HTTP ? "http" : "https") << "://" << uri;
+  url << "/" << (method == GET ? GET_PROTOCOL_PATH : POST_PROTOCOL_VENDOR + "/" + POST_PROTOCOL_VERSION);
   return url.str();
 }
 

src/emitter.hpp

@@ -19,12 +19,14 @@ See the Apache License Version 2.0 for the specific language governing permissio
 #include <condition_variable>
 #include <future>
 #include <thread>
+#include "constants.hpp"
 #include "utils.hpp"
 #include "storage.hpp"
 #include "payload.hpp"
 #include "self_describing_json.hpp"
 #include "http_client.hpp"
 #include "http_request_result.hpp"
+#include "cracked_url.hpp"
 
 using namespace std;
 
@@ -45,19 +47,18 @@ class Emitter {
     HTTPS
   };
 
-  Emitter(const string & uri, Strategy strategy, Method method, Protocol protocol, int send_limit, const string & db_name);
+  Emitter(const string & uri, Strategy strategy, Method method, Protocol protocol, int send_limit, 
+    int byte_limit_post, int byte_limit_get, const string & db_name);
   ~Emitter();
   void start();
   void stop();
   void add(Payload payload);
   void flush();
 
 private:
-  string m_uri;
-  string m_url;
+  CrackedUrl m_url;
   Strategy m_strategy;
   Method m_method;
-  Protocol m_protocol;
   int m_send_limit;
   int m_byte_limit_get;
   int m_byte_limit_post;
@@ -73,7 +74,7 @@ class Emitter {
   void run();
   void do_send(list<Storage::EventRow>* event_rows, list<HttpRequestResult>* results);
   string build_post_data_json(list<Payload> payload_list);
-  string get_collector_url();
+  string get_collector_url(const string & uri, Protocol protocol, Method method);
   bool is_running();
 };