public async Task <IActionResult> PutTrackerEvent([FromRoute] int id, [FromBody] TrackerEvent trackerEvent)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != trackerEvent.Id)
            {
                return(BadRequest());
            }

            _context.Entry(trackerEvent).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TrackerEventExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #2
0
 public void UpdateTrackers(TrackerEvent ev, string id, int port)
 {
     foreach (var tracker in Trackers)
     {
         tracker.Update(this, ev, id, port);
     }
 }
Пример #3
0
        private void HandleMarkerEvent(TrackerEvent <MarkerState> e)
        {
            if (e.type == TrackerEventType.Down)
            {
                if (_markers.TryGetValue(e.id, out var marker))
                {
                    _markers.Remove(e.id);
                    TrackedMarkers.Remove(marker);
                }

                marker = new TrackedMarkerViewModel(e.id, _scaleAdapter);
                marker.UpdateValues(e.state);

                _markers.Add(e.id, marker);
                TrackedMarkers.Add(marker);
            }
            else if (e.type == TrackerEventType.Up)
            {
                if (_markers.TryGetValue(e.id, out var marker))
                {
                    _markers.Remove(e.id);
                    TrackedMarkers.Remove(marker);
                }
            }
            else if (e.type == TrackerEventType.Update)
            {
                if (_markers.TryGetValue(e.id, out var marker))
                {
                    marker.UpdateValues(e.state);
                }
            }
        }
Пример #4
0
        public void DeleteDir(TrackerEvent evnt, int trackerId)
        {
            var files = (
                from t in Trackers
                join f in Files on t.TrackerId equals f.TrackerId
                where t.TrackerId.Equals(trackerId) && f.FullName.IndexOf(evnt.FullName) == 0
                select f
                ).ToList();

            lock (lockObj)
            {
                files.ForEach(file => {
                    file.ChangeList.Add(new Change()
                    {
                        UserId    = GetUserId(evnt, trackerId),
                        EventName = TrackerEvents.Deleted,
                        DateTime  = evnt.DateTime,
                    });
                    file.IsWasDeletedChange = true;
                    file.IsNeedDelete       = true;
                    file.RemoveFromDbTime   = DateTime.UtcNow.AddDays(14);
                });
                SaveChanges();
            }
        }
Пример #5
0
    public override void Send(TrackerEvent e)
    {
        string s = serializer.Serialize(e);

        Debug.Log("Registrado evento: " + s);
        events.Add(s);
    }
Пример #6
0
        public void CreateDir(TrackerEvent evnt, int trackerId)
        {
            var files = (
                from t in Trackers
                join f in Files on t.TrackerId equals f.TrackerId
                join c in Changes on f.FileId equals c.FileId
                where t.TrackerId.Equals(trackerId) && f.FullName.Equals(evnt.FullName)
                select f
                ).ToList();

            lock (lockObj)
            {
                files.ForEach(file => {
                    file.ChangeList.Add(new Change()
                    {
                        UserId    = GetUserId(evnt, trackerId),
                        EventName = TrackerEvents.Created,
                        DateTime  = evnt.DateTime,
                    });
                    file.IsWasDeletedChange = false;
                    file.IsNeedDelete       = false;
                    file.RemoveFromDbTime   = null;
                });
                SaveChanges();
            }
        }
        public IActionResult PostTrackerEvent(string trackerGuid)
        {
            var ipAddress      = HttpContext.Connection.RemoteIpAddress.ToString();
            var whiteListedIPs = _configuration.GetSection("WhiteListedIPs");

            if (!whiteListedIPs.GetChildren().Any(item => item.Key == ipAddress))
            {
                var trackerId = _context.Trackers.Where(t => t.ExternalID.ToString() == trackerGuid)
                                .Select(i => i.TrackerID)
                                .FirstOrDefault();
                var trackerEvent = new TrackerEvent();
                trackerEvent.TrackerID   = trackerId;
                trackerEvent.IPAddress   = ipAddress;
                trackerEvent.CreatedDate = DateTime.Now;

                _context.TrackerEvents.Add(trackerEvent);
                _context.SaveChanges();
            }

            var directory = Directory.GetCurrentDirectory();
            var imagePath = directory + "\\images\\1px.png";
            var b         = System.IO.File.ReadAllBytes(imagePath);

            return(File(b, "image/png"));
        }
Пример #8
0
        public void RenameDir(TrackerEvent evnt, int trackerId)
        {
            var files = (
                from t in Trackers
                join f in Files on t.TrackerId equals f.TrackerId
                where t.TrackerId.Equals(trackerId) && f.FullName.IndexOf(evnt.OldFullName) == 0
                select f
                ).ToList();

            lock (lockObj)
            {
                files.ForEach(file => {
                    file.ChangeList.Add(new Change()
                    {
                        UserId      = GetUserId(evnt, trackerId),
                        EventName   = TrackerEvents.Renamed,
                        DateTime    = evnt.DateTime,
                        OldName     = file.FileName,
                        OldFullName = file.FullName
                    });
                    file.FullName = file.FullName.Replace(evnt.OldFullName, evnt.FullName);
                });
                SaveChanges();
            }
        }
Пример #9
0
 /// <summary>
 /// Change tracker status.
 /// </summary>
 /// <param name="status"></param>
 internal void ChangeStatus(TrackerEvent status)
 {
     announceTimer?.Stop();
     Event = status;
     OnAnnounceEvent(this);
     Event = TrackerEvent.None;  // Reset it back to default on next tick
     announceTimer?.Start();
 }
Пример #10
0
    private void WriteToJson()
    {
        JSONObject   obj   = new JSONObject();
        TrackerEvent auxTE = _eventQueue.Dequeue();

        auxTE.DumpEventDataToJson(ref obj);
        File.AppendAllText(TELEMETRY_PATH + _fileName + ".json", obj.ToString(4) + ",\n");
    }
Пример #11
0
    private void WriteToBinary()
    {
        JSONObject   obj   = new JSONObject();
        TrackerEvent auxTE = _eventQueue.Dequeue();

        auxTE.DumpEventDataToJson(ref obj);
        obj.SaveToBinaryBase64();
        File.AppendAllText(TELEMETRY_PATH + _fileName + ".bn", obj.SaveToBinaryBase64() + "\n");
    }
Пример #12
0
    public void TrackEvent(TrackerEvent e)
    {
        int eventInt = (int)e.eventType;

        if (testing && options != null && eventInt < options.Length && options[eventInt].activated)
        {
            persistenceObject.Send(e);
        }
    }
Пример #13
0
        public void DeletedEvent(TrackerEvent evnt, int trackerId)
        {
            var userId = GetUserId(evnt, trackerId);
            var change = new Change()
            {
                EventName = evnt.EventName,
                DateTime  = evnt.DateTime,
                UserId    = userId,
            };

            AddChange(evnt, change, null, trackerId);
        }
        public async Task <IActionResult> PostTrackerEvent([FromBody] TrackerEvent trackerEvent)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _context.TrackerEvents.Add(trackerEvent);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetTrackerEvent", new { id = trackerEvent.Id }, trackerEvent));
        }
Пример #15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="torrent"></param>
        /// <param name="ev"></param>
        /// <param name="id"></param>
        /// <param name="port"></param>
        public void Update(Torrent torrent, TrackerEvent ev, string id, int port)
        {
            // We should wait for request interval to elapse before asking for new peers
            if (ev == TrackerEvent.Started && DateTime.UtcNow < LastPeerRequest.Add(PeerRequestInterval))
            {
                return;
            }

            LastPeerRequest = DateTime.UtcNow;
            var url = $"{Address}?info_hash={torrent.UrlSafeStringInfohash}&peer_id={id}&port={port}&uploaded={torrent.Uploaded}&downloaded={torrent.Downloaded}&left={torrent.Left}&event={Enum.GetName(typeof(TrackerEvent), ev).ToLower()}&compact=1";

            Request(url);
        }
Пример #16
0
    override public TrackerEvent Deserialize(string s)
    {
        TrackerEvent e = JsonConvert.DeserializeObject <TrackerEvent>(s);

        switch (e.eventType)
        {
        case EventType.AIM:
            return(JsonConvert.DeserializeObject <AimEvent>(s));

        case EventType.TARGET:
            return(JsonConvert.DeserializeObject <TargetEvent>(s));

        default:
            return(e);
        }
    }
Пример #17
0
        private string TrackerEventToString(TrackerEvent trackerEvent)
        {
            if (trackerEvent == TrackerEvent.Started)
            {
                return("started");
            }
            if (trackerEvent == TrackerEvent.Completed)
            {
                return("completed");
            }
            if (trackerEvent == TrackerEvent.Stopped)
            {
                return("stopped");
            }

            throw new Exception("Not supported tracker event format");
        }
Пример #18
0
        public void Update(Torrent torrent, TrackerEvent ev, string id, int port)
        {
            // wait until after request interval has elapsed before asking for new peers
            if (ev == TrackerEvent.Started && DateTime.UtcNow < LastPeerRequest.Add(PeerRequestInterval))
            {
                return;
            }

            LastPeerRequest = DateTime.UtcNow;

            string url = String.Format("{0}?info_hash={1}&peer_id={2}&port={3}&uploaded={4}&downloaded={5}&left={6}&event={7}&compact=1",
                                       Address, torrent.UrlSafeStringInfohash,
                                       id, port,
                                       torrent.Uploaded, torrent.Downloaded, torrent.Left,
                                       Enum.GetName(typeof(TrackerEvent), ev).ToLower());

            Request(url);
        }
Пример #19
0
        public void EndChangeAmbitAsExtensions(TrackerEvent trace)
        {
            var currentAmbitTrace = this.ambitTraces.Pop();
            var currentChanges    = EndChangeAmbit(false);

            if (currentAmbitTrace != trace)
            {
                Debug.LogError("Closed trace ambit is not the topmost trace!!");
            }

            foreach (var varChange in currentChanges)
            {
                TrackerAsset.Instance.setVar(varChange.Key, varChange.Value);
            }
            if (trace != null)
            {
                TrackerAsset.Instance.AddExtensionsToTrace(trace);
            }
        }
Пример #20
0
        public async Task <TrackerResponse> Track(Torrent torrent, TrackerEvent trackerEvent, bool compact = false)
        {
            var hostUrl         = torrent.AnnounceUrl;
            var encodedInfoHash = torrent.Info.GetUrlEncodedInfoHash();

            var formattedTrackerRequestData = FormatTrackerRequestData(encodedInfoHash, torrent.Uploaded, torrent.Downloaded, torrent.Left, trackerEvent, compact);

            var fullUrl         = hostUrl + formattedTrackerRequestData;
            var responseWrapper = await HttpClient.Send(HttpMethod.Get, fullUrl);

            if (!responseWrapper.IsSuccessStatusCode())
            {
                throw new Exception("Request failed");
            }

            var bytes = responseWrapper.ByteContent;

            return(TrackerResponseFactory.GetTrackerResponse(ref bytes));
        }
Пример #21
0
        public void CreatedEvent(TrackerEvent evnt, string path, int trackerId)
        {
            var userId = GetUserId(evnt, trackerId);

            Content content = new Content()
            {
                Payload  = evnt.Content,
                FilePath = path,
            };

            var change = new Change()
            {
                UserId    = userId,
                EventName = evnt.EventName,
                DateTime  = evnt.DateTime,
                Content   = content,
            };

            AddChange(evnt, change, path, trackerId);
        }
Пример #22
0
        public void MoveDir(TrackerEvent evnt, int trackerId)
        {
            var files = (
                from t in Trackers
                join f in Files on t.TrackerId equals f.TrackerId
                where t.TrackerId.Equals(trackerId) && f.FullName.Equals(evnt.OldFullName)
                select f
                ).ToList();

            lock (lockObj)
            {
                files.ForEach(file => {
                    file.ChangeList.Add(new Change()
                    {
                        UserId    = GetUserId(evnt, trackerId),
                        EventName = TrackerEvents.Moved,
                        DateTime  = evnt.DateTime,
                    });
                    file.FullName = evnt.FullName;
                });
                SaveChanges();
            }
        }
Пример #23
0
        private int GetUserId(TrackerEvent evnt, int trackerId)
        {
            var user = (
                from u in Users
                where u.UserName.Equals(evnt.UserName) && u.TrackerId.Equals(trackerId)
                select u
                ).FirstOrDefault();

            if (user == null)
            {
                user = new User()
                {
                    TrackerId = trackerId,
                    UserName  = evnt.UserName,
                };
                Users.Add(user);
                lock (lockObj) {
                    SaveChanges();
                }
            }

            return(user.UserId);
        }
Пример #24
0
 // Adds an event to the event queue
 public void AddEvent(TrackerEvent trackerEvent)
 {
     _eventQueue.Enqueue(trackerEvent);
 }
Пример #25
0
 // Var flag change ambits
 public void BeginChangeAmbit(TrackerEvent trace)
 {
     this.ambitTraces.Push(trace);
     this.varFlagChangeAmbits.Push(new List <KeyValuePair <string, int> >());
     Debug.Log("Opened change ambit " + varFlagChangeAmbits.Count);
 }
Пример #26
0
 virtual public void Send(TrackerEvent e)
 {
 }
Пример #27
0
        private void AddChange(TrackerEvent evnt, Change change, string path, int trackerId)
        {
            var db      = this;
            var tracker = db.Trackers
                          .Include(tr => tr.FileList)
                          .FirstOrDefault(tr => tr.TrackerId == trackerId);

            if (tracker == null)
            {
                return;
            }

            File file;
            bool newFile = false;

            if (evnt.EventName == TrackerEvents.Moved || evnt.EventName == TrackerEvents.Renamed)
            {
                file = tracker.FileList
                       .FirstOrDefault(fl => fl.FullName.Equals(evnt.OldFullName));

                if (file == null)
                {
                    file = new File()
                    {
                        FullName = evnt.FullName,
                        FileName = evnt.Name,
                    };
                    newFile = true;
                }

                if (evnt.EventName == TrackerEvents.Moved)
                {
                    file.FullName = evnt.FullName;
                }
                else
                {
                    file.FileName = evnt.Name;
                    file.FullName = evnt.FullName;
                }
            }
            else
            {
                file = tracker.FileList
                       .FirstOrDefault(fl => fl.FullName.Equals(evnt.FullName));

                if (file == null)
                {
                    file = new File()
                    {
                        FullName = evnt.FullName,
                        FileName = evnt.Name,
                    };
                    newFile = true;
                }
                if (evnt.EventName == TrackerEvents.Created)
                {
                    file.IsWasDeletedChange = false;
                    file.IsNeedDelete       = false;
                    file.RemoveFromDbTime   = null;
                }
                if (evnt.EventName == TrackerEvents.Deleted)
                {
                    file.IsWasDeletedChange = true;
                    file.RemoveFromDbTime   = DateTime.UtcNow.AddDays(14);
                }
            }

            if (!String.IsNullOrEmpty(path))
            {
                file.FilePath = path;
            }

            lock (lockObj) {
                file.ChangeList.Add(change);
                if (newFile)
                {
                    tracker.FileList.Add(file);
                }
                db.SaveChanges();
            }
        }
Пример #28
0
 public override string Serialize(TrackerEvent e)
 {
     return(JsonConvert.SerializeObject(e, Tracker.getInstance().jsonFormatting).ToString());
 }
 /// <summary>
 /// Adds the given value to the Queue.
 /// </summary>
 ///
 /// <param name="value"> New value for the variable. </param>
 public void Trace(TrackerEvent value)
 {
     queue.Enqueue(value);
 }
Пример #30
0
 public TrackerContext(TrackerEvent trackerEvent, string userId)
 {
     TrackerEvent = trackerEvent;
     UserId       = userId;
 }
Пример #31
0
 private static KeyValuePair <TrackerEvent, Action <ILogger, string, Exception> > CreateSuccessMessageKvp(TrackerEvent trackerEvent, string messageWithPlaceholder)
 => new KeyValuePair <TrackerEvent, Action <ILogger, string, Exception> >(trackerEvent, LoggerMessage.Define <string>(LogLevel.Information, (int)trackerEvent, messageWithPlaceholder));