/// <summary>
        /// Returns the free busy times for the specified exchange users
        /// </summary>
        /// <param name="users">The user which free/busy blocks will be looked up for</param>
        /// <param name="window">The time period to look up FB info for</param>
        /// <returns></returns>
        public Dictionary<ExchangeUser, FreeBusy> LookupFreeBusyTimes(
            ExchangeUserDict users,
            DateTimeRange window )
        {
            /* Create an array of mailboxes to retrieve from exchange */
            Dictionary<ExchangeUser, FreeBusy> result = new Dictionary<ExchangeUser, FreeBusy>();

            try
            {
                using (BlockTimer bt = new BlockTimer("LookupFreeBusyTimes"))
                {
                    /* Perform the retrieval of free busy times through WebDav */
                    result = webDavQuery.LoadFreeBusy(exchangeServerUrl, users, window);
                }
            }
            catch (Exception ex)
            {
                throw new GCalExchangeException(
                    GCalExchangeErrorCode.ExchangeUnreachable,
                   "Error occured while retrieving free busy ranges",
                   ex);
            }

            return result;
        }
예제 #2
0
        /// <summary>
        /// Load a set of appointments from the server
        /// </summary>
        /// <param name="folderUrl">The mailbox URL</param>
        /// <param name="start">Start time of date range to fetch</param>
        /// <param name="end">End time of date range to fetch</param>
        /// <returns>A list of appointments from the mailbox</returns>
        public virtual List<Appointment> LoadAppointments(
            string folderUrl, DateTime start, DateTime end)
        {
            using (BlockTimer bt = new BlockTimer("LoadAppointments"))
            {
                string request = WebDavXmlResources.GetText(
                    WebDavXmlResources.FindAppointments,
                    folderUrl,
                    DateUtil.FormatDateForDASL(start),
                    DateUtil.FormatDateForDASL(end));

                string response = IssueRequestAndFetchReponse(folderUrl, Method.SEARCH, request);
                XmlDocument responseXML = ParseExchangeXml(response);
                return ParseAppointmentResultSetXml(responseXML);
            }
        }
        /// <summary>
        /// Perform sync of users from Google Calendar to Exchnage until there are no more
        /// users to sync. This can be called from a worker thread.
        /// </summary>
        public void SyncUsers()
        {
            ExchangeUser user;
            int userCount = 0;
            string login = string.Empty;

            errorThreshold = ConfigCache.ServiceErrorCountThreshold;
            errorCount = 0;

            while ( exchangeUsers.Count > 0 )
            {
                lock ( lockObject )
                {
                    if ( exchangeUsers.Count == 0 )
                    {
                        break;
                    }
                    else
                    {
                        user = exchangeUsers[0];
                        exchangeUsers.RemoveAt( 0 );
                    }
                }

                try
                {
                    userCount++;

                    login = user.Email.ToLower();

                    DateTime modifiedDate = modifiedDateUtil.GetModifiedDateForUser(login);
                    DateTime currentDate = DateUtil.NowUtc;

                    // Pick a window to synchronize for:
                    //
                    // [-N, +2N] days where N is settable in the config file
                    //
                    // Scanning back in time is necessary so that we pickup changes to meetings and events that were
                    // made invisible.
                    //
                    // TODO: The window we're syncing for should also be used when we modify events in Exchange
                    // so we only modify events in the window.

                    DateTime start = currentDate.AddDays(-ConfigCache.GCalSyncWindow);
                    DateTime end = currentDate.AddDays(2 * ConfigCache.GCalSyncWindow);
                    DateTimeRange syncWindow = new DateTimeRange(start, end);

                    log.InfoFormat("Processing user {0} for {1}", login, syncWindow);

                    EventFeed feed = gcalGateway.QueryGCal(
                        user.Email,
                        GCalVisibility.Private,
                        ConfigCache.FreeBusyDetailLevel,
                        modifiedDate,
                        syncWindow);

                    // if feed is null, then that means no calendar items changed for the user since we last queried.
                    if ( feed == null )
                    {
                        log.DebugFormat(
                            "Calendar has not changed for user {0}.  User will not be synced this round.",
                            login );

                        continue;
                    }

                    if ( !ValidateFeed( feed ) )
                    {
                        /* No Google App Feed was returned,  skip to next user */
                        log.WarnFormat(
                            "GCal feed could not be read for '{0}'.  This user may not have activated their account or may be inactive." +
                            "For resources the admin must share their calendars for the domain and set correctly the timezone.",
                            login );

                        continue;
                    }

                    log.InfoFormat("Calendar Query returned {0} events", feed.Entries.Count);

                    using (BlockTimer freeBusyTimer = new BlockTimer("WriteFreeBusy"))
                    {
                        /* User and feed retrieval was succesful, merge the two datasources down into Exchange */
                        freeBusyWriter.SyncUser( user, feed, exchangeGateway, syncWindow );
                    }

                    // Only update the modified time if we sync'd
                    modifiedDateUtil.UpdateUserModifiedTime(login, currentDate);
                }
                catch ( Exception ex )
                {
                    Interlocked.Increment( ref errorCount );

                    log.Error( string.Format(
                        "Error occured while executing sync process for user '{0}'. [running error count={1}]", login, errorCount ),
                        ex );
                }

                if ( errorCount > errorThreshold )
                    throw new GCalExchangeException(
                        GCalExchangeErrorCode.GenericError,
                        "Error threshold has been surpassed, aborting sync process." );

            }

            log.InfoFormat( "User synchronization complete.  {0} users processed.", userCount );
        }
        /// <summary>
        /// Run the sync process from Google Calendar to Exchange
        /// </summary>
        /// <param name="threadCount">Number of threads to use to sync</param>
        public void RunSyncProcess( int threadCount )
        {
            log.Info( "Exchange synchronization process started." );

            using ( BlockTimer bt = new BlockTimer( "RunSyncProcess" ) )
            {
                gcalGateway =
                    new GCalGateway(googleAppsLogin, googleAppsPassword, googleAppsDomain, null);
                exchangeGateway =
                    new ExchangeService(exchangeServer, networkLogin, networkPassword);

                ExchangeUserDict users;

                using ( BlockTimer loadUserTimer = new BlockTimer( "LoadUserList" ) )
                {
                    users = QueryExchangeForValidUsers();
                }

                exchangeUsers = new List<ExchangeUser>();

                freeBusyWriter = FreeBusyWriterFactory.GetWriter( exchangeUsers );

                foreach ( ExchangeUser user in users.Values )
                {
                    exchangeUsers.Add( user );
                }

                if ( exchangeUsers.Count == 0 )
                {
                    log.Warn( "No eligible users found for synchronization.  Aborting sync process." );
                    return;
                }

                if ( threadCount < 1 )
                    threadCount = 1;

                modifiedDateUtil = new ModifiedDateUtil( ConfigCache.ServiceModifiedXmlFileName );
                modifiedDateUtil.LoadModifiedTimes();

                if ( threadCount == 1 )
                {
                    SyncUsers();
                }
                else
                {
                    StartSyncUserThreads( threadCount );
                }

                modifiedDateUtil.PersistModifiedTimes();

                gcalGateway = null;
                exchangeGateway = null;
                freeBusyWriter = null;
                modifiedDateUtil = null;
                exchangeUsers = null;

                System.GC.Collect();
                log.DebugFormat("Memory after sync: {0}", System.GC.GetTotalMemory(false));
            }
        }
        /// <summary>
        /// Combines the free busy and appointment blocks supplied to the exchange user object
        /// If no appointments are supplied the user will still have free busy time blocks assigned
        /// to them, with a null appointment assigned to the free busy time.
        /// </summary>
        /// <param name="exchangeUser">Exchange users to apply freeBusy and appointments</param>
        /// <param name="freeBusy">The collection of FreeBusy blocks to assign to exchangeUser</param>
        /// <param name="appointments">The collection of appointment blocks to assign to exchangeUser</param>
        /// <param name="window">Window to merge for</param>
        protected void MergeFreeBusyWithAppointments(
            ExchangeUser exchangeUser,
            FreeBusy freeBusy,
            List<Appointment> appointments,
            DateTimeRange window)
        {
            using (BlockTimer bt = new BlockTimer("MergeFreeBusyWithAppointments"))
            {
                IntervalTree<FreeBusyTimeBlock> busyIntervals =
                    new IntervalTree<FreeBusyTimeBlock>();
                FreeBusyCollection busyTimes = new FreeBusyCollection();
                int appointmentsCount = 0;
                List<DateTimeRange> combinedTimes =
                    FreeBusyConverter.MergeFreeBusyLists(freeBusy.All, freeBusy.Tentative);

                /* Add the date ranges from each collection in the FreeBusy object */
                ConvertFreeBusyToBlocks(window,
                                        combinedTimes,
                                        busyTimes,
                                        busyIntervals);

                if (appointments != null && appointments.Count > 0)
                {
                    appointmentsCount = appointments.Count;
                    foreach (Appointment appt in appointments)
                    {
                        log.DebugFormat("Appt \"{0}\" {1} {2} response = {3} status = {4} busy = {5}",
                                        appt.Subject,
                                        appt.Range,
                                        appt.StartDate.Kind,
                                        appt.ResponseStatus,
                                        appt.MeetingStatus,
                                        appt.BusyStatus);

                        if (appt.BusyStatus == BusyStatus.Free)
                        {
                            continue;
                        }

                        DateTimeRange range = new DateTimeRange(appt.StartDate, appt.EndDate);
                        List<FreeBusyTimeBlock> result =
                            busyIntervals.FindAll(range, IntervalTreeMatch.Overlap);

                        log.DebugFormat("Found {0} ranges overlap {1}", result.Count, range);

                        foreach (FreeBusyTimeBlock block in result)
                        {
                            log.DebugFormat("Adding \"{0}\" to FB {1} {2}",
                                            appt.Subject,
                                            block.Range,
                                            block.StartDate.Kind);
                            block.Appointments.Add(appt);
                        }

                        busyTimes.Appointments.Add(appt);
                    }
                }

                foreach (FreeBusyTimeBlock block in busyTimes.Values)
                {
                    block.Appointments.Sort(CompareAppointmentsByRanges);
                }

                log.InfoFormat("Merge Result of {0} + Appointment {1} -> {2}",
                               combinedTimes.Count,
                               appointmentsCount,
                               busyTimes.Count);

                /* Assign the data structure to the exchange user */
                exchangeUser.BusyTimes = busyTimes;
            }
        }
예제 #6
0
        private EventFeed QueryGCal(FeedQuery query, string userName, DateTime modifiedSince)
        {
            if (log.IsInfoEnabled)
                log.Info(String.Format("Querying GCal for User '{0}': {1}", userName, query.Uri));

            EventFeed feed = null;

            // Wait as necessary before making new request.

            connectionThrottler.WaitBeforeNewConnection();

            try
            {
                using (BlockTimer bt = new BlockTimer("QueryGCal"))
                {
                    feed = service.Query(query, modifiedSince) as EventFeed;
                }

            }
            catch (GDataNotModifiedException e)
            {
                // Content was not modified
                log.InfoFormat("NotModified: {0}", e.Message);
            }
            catch (Exception)
            {
                // Report a failure, regardless of the exception, as long as it is not GDataNotModifiedException.
                // This could be a bit overly aggressive, but it is hard to make bets
                // what exception was caught and rethrown in GData and what was let to fly.
                connectionThrottler.ReportFailure();

                throw;
            }

            // Everything went well, report it.
            // Note this is valid even when we caught GDataNotModifiedException.
            connectionThrottler.ReportSuccess();

            LogResponse(feed, userName);

            return feed;
        }