Example #1
0
 public void Init(IActivityHandler activityHandler, ActivityPackage attributionPackage, bool startPaused, bool hasDelegate)
 {
     ActivityHandler = activityHandler;
     AttributionPackage = attributionPackage;
     Paused = startPaused;
     HasDelegate = hasDelegate;
 }
Example #2
0
 public void SendPackage(ActivityPackage package)
 {
     Task.Factory.StartNew(() => SendInternal(package))
         // continuation used to prevent unhandled exceptions in SendInternal
         // not signaling the WaitHandle in PackageHandler and preventing deadlocks
         .ContinueWith((sendResponse) => PackageSent(sendResponse));
 }
Example #3
0
 private HttpClient GetHttpClient(ActivityPackage activityPackage)
 {
     if (HttpClient == null)
     {
         HttpClient = Util.BuildHttpClient(activityPackage.ClientSdk);
     }
     return HttpClient;
 }
Example #4
0
        public static IAttributionHandler GetAttributionHandler(IActivityHandler activityHandler,
            ActivityPackage attributionPacakage,
            bool startPaused,
            bool hasDelegate)
        {
            if (IAttributionHandler == null)
            {
                return new AttributionHandler(activityHandler, attributionPacakage, startPaused, hasDelegate);
            }

            IAttributionHandler.Init(activityHandler, attributionPacakage, startPaused, hasDelegate);
            return IAttributionHandler;
        }
Example #5
0
        public AttributionHandler(IActivityHandler activityHandler, ActivityPackage attributionPackage, bool startPaused, bool hasDelegate)
        {
            Logger = AdjustFactory.Logger;

            InternalQueue = new ActionQueue("adjust.AttributionHandler");

            Init(activityHandler: activityHandler,
                attributionPackage: attributionPackage,
                startPaused: startPaused,
                hasDelegate: hasDelegate);

            Timer = new TimerOnce(actionQueue: InternalQueue, action: GetAttributionInternal);
        }
Example #6
0
        private HttpResponseMessage ExecuteRequest(ActivityPackage activityPackage)
        {
            var httpClient = GetHttpClient(activityPackage);
            var url = Util.BaseUrl + activityPackage.Path;

            var sNow = Util.DateFormat(DateTime.Now);
            activityPackage.Parameters["sent_at"] = sNow;

            using (var parameters = new FormUrlEncodedContent(activityPackage.Parameters))
            {
                return httpClient.PostAsync(url, parameters).Result;
            }
        }
        private ResponseData SendI(ActivityPackage activityPackage, int queueSize)
        {
            ResponseData responseData;

            try
            {
                using (var httpResponseMessage = Util.SendPostRequest(activityPackage, queueSize))
                {
                    responseData = Util.ProcessResponse(httpResponseMessage, activityPackage);
                }
            }
            catch (HttpRequestException hre)
            {
                var we = hre.InnerException as WebException;
                responseData = we == null?
                               ProcessException(hre, activityPackage) :
                                   ProcessWebException(we, activityPackage);
            }
            catch (WebException we) { responseData = ProcessWebException(we, activityPackage); }
            catch (Exception ex) { responseData = ProcessException(ex, activityPackage); }

            return(responseData);
        }
Example #8
0
        public static HttpResponseMessage SendPostRequest(ActivityPackage activityPackage, string basePath, int queueSize)
        {
            string baseUrl = activityPackage.ActivityKind != ActivityKind.Gdpr
                ? AdjustFactory.BaseUrl
                : AdjustFactory.GdprUrl;

            string url = basePath != null
                ? baseUrl + basePath + activityPackage.Path
                : baseUrl + activityPackage.Path;

            var sNow = DateFormat(DateTime.Now);

            activityPackage.Parameters[SENT_AT] = sNow;

            Dictionary <string, string> parameters = new Dictionary <string, string>(activityPackage.Parameters);

            ExtractEventCallbackId(parameters);
            string secretId  = ExtractSecretId(parameters);
            string appSecret = ExtractAppSecret(parameters);

            string activityKind        = Enum.GetName(typeof(ActivityKind), activityPackage.ActivityKind);
            string authorizationHeader =
                BuildAuthorizationHeader(parameters, appSecret, secretId, activityKind);

            SetUserAgent();
            SetAuthorizationParameter(authorizationHeader);

            if (queueSize > 0)
            {
                parameters.Add(QUEUE_SIZE, queueSize.ToString());
            }

            using (var postParams = new FormUrlEncodedContent(parameters))
            {
                return(_httpClient.PostAsync(url, postParams).Result);
            }
        }
Example #9
0
        private SendResponse ProcessException(WebException webException, ActivityPackage activityPackage)
        {
            using (var response = webException.Response as HttpWebResponse)
            {
                int? statusCode = (response == null) ? null : (int?)response.StatusCode;

                var sendResponse = new SendResponse
                {
                    WillRetry = true,
                    JsonDict = Util.ParseJsonExceptionResponse(response)
                };

                Logger.Error("{0}. ({1}, Status code: {2}). Will retry later.",
                    activityPackage.FailureMessage(),
                    Util.ExtractExceptionMessage(webException),
                    statusCode);

                return sendResponse;
            }
        }
Example #10
0
        private SendResponse ProcessException(Exception exception, ActivityPackage activityPackage)
        {
            Logger.Error("{0}. ({1}). Will retry later", activityPackage.FailureMessage(), Util.ExtractExceptionMessage(exception));

            return new SendResponse
            {
                WillRetry = true,
            };
        }
 public void Init(IActivityHandler activityHandler, ActivityPackage attributionPackage, bool startPaused, bool hasDelegate)
 {
     MockLogger.Test("{0} Init, startPaused {1}, hasDelegate {2}", prefix, startPaused, hasDelegate);
 }
Example #12
0
 public void Init(IActivityHandler activityHandler, ActivityPackage attributionPackage, bool startPaused)
 {
     _activityHandler    = activityHandler;
     _attributionPackage = attributionPackage;
     _paused             = startPaused;
 }
Example #13
0
        private SendResponse ProcessResponse(HttpResponseMessage httpResponseMessage, ActivityPackage activityPackage)
        {
            var sendResponse = new SendResponse
            {
                WillRetry = false,
                JsonDict = Util.ParseJsonResponse(httpResponseMessage),
            };

            if (httpResponseMessage.StatusCode == HttpStatusCode.InternalServerError   // 500
                || httpResponseMessage.StatusCode == HttpStatusCode.NotImplemented)    // 501
            {
                Logger.Error("{0}. (Status code: {1}).",
                    activityPackage.FailureMessage(),
                    (int)httpResponseMessage.StatusCode);
            }
            else if (!httpResponseMessage.IsSuccessStatusCode)
            {
                sendResponse.WillRetry = true;

                Logger.Error("{0}. (Status code: {1}). Will retry later.",
                    activityPackage.FailureMessage(),
                    (int)httpResponseMessage.StatusCode);
            }

            return sendResponse;
        }
Example #14
0
 public void SendPackage(ActivityPackage package)
 {
     MockLogger.Test("{0} SendPackage, {1}", prefix, package);
 }
Example #15
0
        // does not close stream received. Caller is responsible to close if it wants it
        internal static ActivityPackage DeserializeFromStream(Stream stream)
        {
            ActivityPackage activityPackage = null;
            var reader = new BinaryReader(stream);

            activityPackage = new ActivityPackage();
            activityPackage.Path = reader.ReadString();
            reader.ReadString(); //activityPackage.UserAgent
            activityPackage.ClientSdk = reader.ReadString();
            activityPackage.ActivityKind = ActivityKindUtil.FromString(reader.ReadString());
            activityPackage.Suffix = reader.ReadString();

            var parameterLength = reader.ReadInt32();
            activityPackage.Parameters = new Dictionary<string, string>(parameterLength);

            for (int i = 0; i < parameterLength; i++)
            {
                activityPackage.Parameters.Add(
                    reader.ReadString(),
                    reader.ReadString()
                );
            }

            return activityPackage;
        }
Example #16
0
        public static ResponseData ProcessResponse(HttpResponseMessage httpResponseMessage, ActivityPackage activityPackage)
        {
            var jsonDic = ParseJsonResponse(httpResponseMessage);

            return(ProcessResponse(jsonDic, (int?)httpResponseMessage?.StatusCode, activityPackage));
        }
Example #17
0
 public void AddPackage(ActivityPackage activityPackage)
 {
     MockLogger.Test("{0} AddPackage", prefix);
     PackageQueue.Add(activityPackage);
 }
Example #18
0
        private SendResponse SendInternal(ActivityPackage activityPackage)
        {
            SendResponse sendResponse;
            try
            {
                using (var httpResponseMessage = ExecuteRequest(activityPackage))
                {
                    sendResponse = ProcessResponse(httpResponseMessage, activityPackage);
                }
            }
            catch (WebException we) { sendResponse = ProcessException(we, activityPackage); }
            catch (Exception ex) { sendResponse = ProcessException(ex, activityPackage); }

            return sendResponse;
        }
Example #19
0
 public void AddPackage(ActivityPackage activityPackage)
 {
     _actionQueue.Enqueue(() => AddI(activityPackage));
 }
Example #20
0
        private void AddInternal(ActivityPackage activityPackage)
        {
            if (activityPackage.ActivityKind.Equals(ActivityKind.Click) && PackageQueue.Count > 0)
            {
                PackageQueue.Insert(1, activityPackage);
            }
            else
            {
                PackageQueue.Add(activityPackage);
            }

            Logger.Debug("Added package {0} ({1})", PackageQueue.Count, activityPackage);
            Logger.Verbose("{0}", activityPackage.GetExtendedString());

            WritePackageQueue();
        }
Example #21
0
        // does not close stream received. Caller is responsible to close if it wants it
        internal static void SerializeToStream(Stream stream, ActivityPackage activityPackage)
        {
            var writer = new BinaryWriter(stream);

            writer.Write(activityPackage.Path);
            writer.Write("");
            writer.Write(activityPackage.ClientSdk);
            writer.Write(ActivityKindUtil.ToString(activityPackage.ActivityKind));
            writer.Write(activityPackage.Suffix);

            var parametersArray = activityPackage.Parameters.ToArray();
            writer.Write(parametersArray.Length);
            for (int i = 0; i < parametersArray.Length; i++)
            {
                writer.Write(parametersArray[i].Key);
                writer.Write(parametersArray[i].Value);
            }
        }
Example #22
0
 public void AddPackage(ActivityPackage activityPackage)
 {
     InternalQueue.Enqueue(() => AddInternal(activityPackage));
 }
Example #23
0
        private SendResponse ProcessResponse(HttpResponseMessage httpResponseMessage, ActivityPackage activityPackage)
        {
            var sendResponse = new SendResponse
            {
                WillRetry = false,
                JsonDict  = Util.ParseJsonResponse(httpResponseMessage),
            };

            if (httpResponseMessage.StatusCode == HttpStatusCode.InternalServerError || // 500
                httpResponseMessage.StatusCode == HttpStatusCode.NotImplemented)        // 501
            {
                Logger.Error("{0}. (Status code: {1}).",
                             activityPackage.FailureMessage(),
                             (int)httpResponseMessage.StatusCode);
            }
            else if (!httpResponseMessage.IsSuccessStatusCode)
            {
                sendResponse.WillRetry = true;

                Logger.Error("{0}. (Status code: {1}). Will retry later.",
                             activityPackage.FailureMessage(),
                             (int)httpResponseMessage.StatusCode);
            }

            return(sendResponse);
        }
Example #24
0
 public void AddPackage(ActivityPackage activityPackage)
 {
     InternalQueue.Enqueue(() => AddInternal(activityPackage));
 }