couchbase / couchbase-lite-ios / 943

pending completion

Build # 943

Build Type

push

travis-ci

Committed by

jayahariv

Commit Message

<a href="https://github.com/couchbase/couchbase-lite-ios/commit/<a class=hub.com/couchbase/couchbase-lite-ios/commit/<a class="double-link" href="https://git"><a class=hub.com/couchbase/couchbase-lite-ios/commit/<a class="double-link" href="https://git"><a class=hub.com/couchbase/couchbase-lite-ios/commit/<a class="double-link" href="https://git"><a class=hub.com/couchbase/couchbase-lite-ios/commit/4821e3784292acd0150f4489baa0c12f6797aecb">4821e3784">&lt;a href=&quot;https://github.com/couchbase/couchbase-lite-ios/commit/</a><a class="double-link" href="https://github.com/couchbase/couchbase-lite-ios/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/couchbase/couchbase-lite-ios/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/couchbase/couchbase-lite-ios/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/couchbase/couchbase-lite-ios/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/couchbase/couchbase-lite-ios/commit/4821e3784292acd0150f4489baa0c12f6797aecb">4821e3784</a><a href="https://github.com/couchbase/couchbase-lite-ios/commit/4821e3784292acd0150f4489baa0c12f6797aecb">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/couchbase/couchbase-lite-ios/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/couchbase/couchbase-lite-ios/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/couchbase/couchbase-lite-ios/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/couchbase/couchbase-lite-ios/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/couchbase/couchbase-lite-ios/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/couchbase/couchbase-lite-ios/commit/4821e3784292acd0150f4489baa0c12f6797aecb&quot;&gt;4821e3784&lt;/a&gt;&lt;a href=&quot;https://github.com/couchbase/couchbase-lite-ios/commit/4821e3784292acd0150f4489baa0c12f6797aecb&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com... (continued)

Run Details

6547 of 8550 relevant lines covered (76.57%)

1365.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.58

/Objective-C/Internal/Replicator/CBLReachability.m

//
//  CBLReachability.m
//  CouchbaseLite
//
//  Copyright (c) 2017 Couchbase, Inc All rights reserved.
//
//  Licensed 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.
//

#import "CBLReachability.h"
#import "CBLReplicator+Internal.h"
#import <SystemConfiguration/SystemConfiguration.h>
#import <arpa/inet.h>

@interface CBLReachability ()
@property (readwrite, nonatomic) BOOL reachabilityKnown;
@property (readwrite, nonatomic) SCNetworkReachabilityFlags reachabilityFlags;
@end

@implementation CBLReachability
{
    NSString* _hostName;
    SCNetworkReachabilityRef _ref;
    CFRunLoopRef _runLoop;
    dispatch_queue_t _queue;
    SCNetworkReachabilityFlags _reachabilityFlags;
    BOOL _reachabilityKnown;
    BOOL _usingProxy;
    CBLReachabilityOnChangeBlock _onChange;
}

@synthesize hostName=_hostName, onChange=_onChange,
            reachabilityKnown=_reachabilityKnown, reachabilityFlags=_reachabilityFlags;

#if DEBUG
static BOOL sAlwaysAssumeProxy = NO;
+ (void) setAlwaysAssumesProxy: (BOOL)alwaysAssumesProxy {
    sAlwaysAssumeProxy = alwaysAssumesProxy;
}
#endif

+ (BOOL) usingProxyForURL: (NSURL*)url {
    NSDictionary* settings = CFBridgingRelease(CFNetworkCopySystemProxySettings());
    NSArray* proxies = CFBridgingRelease(CFNetworkCopyProxiesForURL((__bridge CFURLRef)url,
                                                                    (__bridge CFDictionaryRef)settings));
    for (NSDictionary* proxy in proxies) {
        if (![proxy[(id)kCFProxyTypeKey] isEqual: (id)kCFProxyTypeNone])
            return YES;
    }
#if DEBUG
    return sAlwaysAssumeProxy;
#endif
    return NO;
}

- (instancetype) initWithReachabilityRef: (CF_RELEASES_ARGUMENT SCNetworkReachabilityRef)ref {
    self = [super init];
    if (self) {
        _ref = ref;
    }
    return self;
}

- (instancetype) init {
    struct sockaddr_in addr = {sizeof(addr), AF_INET};  // IP address 0.0.0.0
    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithAddress(NULL,
                                                                          (struct sockaddr*)&addr);
    return [self initWithReachabilityRef: ref];
}

- (instancetype) initWithURL: (NSURL*)url {
    NSString* hostName = url.host;
    if (!hostName.length)
        hostName = @"localhost";
    // If network access requires a proxy, just track whether there is any network connection:
    if ([[self class] usingProxyForURL: url]) {
        self = [self init];
        if (self)
            _usingProxy = YES;
    } else {
        self = [self initWithReachabilityRef: SCNetworkReachabilityCreateWithName(NULL,
                                                                          hostName.UTF8String)];
    }
    if (self) {
        _hostName = [hostName copy];
    }
    return self;
}

- (BOOL) setupCallback {
    SCNetworkReachabilityContext context = {0, (__bridge void *)(self)};
    return _ref && SCNetworkReachabilitySetCallback(_ref, ClientCallback, &context);
}

- (BOOL) removeCallback {
    return _ref && SCNetworkReachabilitySetCallback(_ref, NULL, NULL);
}

- (BOOL) startOnRunLoop: (CFRunLoopRef)runLoop {
    if (_runLoop || _queue)
        return (_runLoop == runLoop);
    if (![self setupCallback])
        return NO;
    if (!SCNetworkReachabilityScheduleWithRunLoop(_ref, runLoop, kCFRunLoopCommonModes))
        return NO;
    _runLoop = (CFRunLoopRef) CFRetain(runLoop);
    return [self started];
}

- (BOOL) startOnQueue: (dispatch_queue_t)queue {
    if (_runLoop || _queue)
        return _queue == queue;
    if (![self setupCallback])
        return NO;
    if (!SCNetworkReachabilitySetDispatchQueue(_ref, queue))
        return NO;
    _queue = queue;
    return [self started];
}

- (BOOL) started {
    // See whether status is already known:
    SCNetworkReachabilityFlags flag;
    if (SCNetworkReachabilityGetFlags(_ref, &flag)) {
        CBLLogInfo(Sync, @"%@: flags=%x; starting...", self, flag);
        [self notifyFlagsChanged: flag];
    } else {
        CBLLogInfo(Sync, @"%@: starting...", self);
    }
    return YES;
}

- (void) notifyFlagsChanged: (SCNetworkReachabilityFlags)flags {
    if (_queue) {
        dispatch_async(_queue, ^{
            [self flagsChanged: flags];
        });
    } else {
        Assert(_runLoop);
        CFRunLoopPerformBlock(_runLoop, kCFRunLoopCommonModes, ^{
            [self flagsChanged: flags];
        });
    }
}

- (void) stop {
    _reachabilityKnown = NO;
    if (_runLoop || _queue)
        CBLLogInfo(Sync, @"%@: stopped", self);
    
    if (![self removeCallback])
        CBLWarn(Sync, @"%@: cannot remove reachability callback", self);
    
    if (_runLoop) {
        SCNetworkReachabilityUnscheduleFromRunLoop(_ref, _runLoop, kCFRunLoopCommonModes);
        CFRelease(_runLoop);
        _runLoop = NULL;
    }
    if (_queue) {
        SCNetworkReachabilitySetDispatchQueue(_ref, NULL);
        _queue = NULL;
    }
}

- (void)dealloc {
    if (_ref) {
        [self stop];
        CFRelease(_ref);
    }
}

- (NSString*) status {
    if (!self.reachable)
        return @"unreachable";
#if TARGET_OS_IPHONE
    else if (!self.reachableByWiFi)
        return @"reachable (3G)";
#endif
    else
        return @"reachable";
}

- (NSString*) description {
    NSString* desc;
    if (!_hostName)
        desc = @"Reachability<(any)>";
    else if (_usingProxy)
        desc = $sprintf(@"Reachability<(proxy to)%@>", _hostName);
    else
        desc = $sprintf(@"Reachability<%@>", _hostName);
    return desc;
}

- (BOOL) reachable {
    // We want 'reachable' flag to be on, but not if user intervention is required (like PPP login)
    SCNetworkReachabilityFlags flags;
    if (_reachabilityKnown)
        flags = _reachabilityFlags;
    else if (!SCNetworkReachabilityGetFlags(_ref, &flags))
        return false;
    
    return (flags & kSCNetworkReachabilityFlagsReachable) && !(flags & kSCNetworkReachabilityFlagsInterventionRequired);
}

- (BOOL) reachableByWiFi {
    return self.reachable
#if TARGET_OS_IPHONE
        && !(_reachabilityFlags & kSCNetworkReachabilityFlagsIsWWAN)
#endif
    ;
}

+ (NSSet*) keyPathsForValuesAffectingReachable {
    return [NSSet setWithObjects: @"reachabilityKnown", @"reachabilityFlags", nil];
}

+ (NSSet*) keyPathsForValuesAffectingReachableByWiFi {
    return [NSSet setWithObjects: @"reachabilityKnown", @"reachabilityFlags", nil];
}

- (void) flagsChanged: (SCNetworkReachabilityFlags)flags {
    if (!_reachabilityKnown || flags != _reachabilityFlags) {
        self.reachabilityFlags = flags;
        self.reachabilityKnown = YES;
        CBLLogInfo(Sync, @"%@: flags <-- %x", self, flags);
        __typeof(_onChange) onChange = _onChange;
        if (onChange)
            onChange();
    }
}

static void ClientCallback(SCNetworkReachabilityRef target,
                           SCNetworkReachabilityFlags flags,
                           void *info)
{
    [(__bridge CBLReachability*)info flagsChanged: flags];
}

@end

1	//
2	// CBLReachability.m
3	// CouchbaseLite
4	//
5	// Copyright (c) 2017 Couchbase, Inc All rights reserved.
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19
20	#import "CBLReachability.h"
21	#import "CBLReplicator+Internal.h"
22	#import <SystemConfiguration/SystemConfiguration.h>
23	#import <arpa/inet.h>
24
25	@interface CBLReachability ()
26	@property (readwrite, nonatomic) BOOL reachabilityKnown;
27	@property (readwrite, nonatomic) SCNetworkReachabilityFlags reachabilityFlags;
28	@end
29
30	@implementation CBLReachability
31	{
32	NSString* _hostName;
33	SCNetworkReachabilityRef _ref;
34	CFRunLoopRef _runLoop;
35	dispatch_queue_t _queue;
36	SCNetworkReachabilityFlags _reachabilityFlags;
37	BOOL _reachabilityKnown;
38	BOOL _usingProxy;
39	CBLReachabilityOnChangeBlock _onChange;
40	}
41
42	@synthesize hostName=_hostName, onChange=_onChange,
43	reachabilityKnown=_reachabilityKnown, reachabilityFlags=_reachabilityFlags;
44
45	#if DEBUG
46	static BOOL sAlwaysAssumeProxy = NO;
47	+ (void) setAlwaysAssumesProxy: (BOOL)alwaysAssumesProxy {	×
48	sAlwaysAssumeProxy = alwaysAssumesProxy;	×
49	}	×
50	#endif
51
52	+ (BOOL) usingProxyForURL: (NSURL*)url {	1✔
53	NSDictionary* settings = CFBridgingRelease(CFNetworkCopySystemProxySettings());	1✔
54	NSArray* proxies = CFBridgingRelease(CFNetworkCopyProxiesForURL((__bridge CFURLRef)url,	1✔
55	(__bridge CFDictionaryRef)settings));	1✔
56	for (NSDictionary* proxy in proxies) {	1✔
57	if (![proxy[(id)kCFProxyTypeKey] isEqual: (id)kCFProxyTypeNone])	1✔
58	return YES;	×
59	}	1✔
60	#if DEBUG	1✔
61	return sAlwaysAssumeProxy;	1✔
62	#endif	1✔
63	return NO;	1✔
64	}	1✔
65
66	- (instancetype) initWithReachabilityRef: (CF_RELEASES_ARGUMENT SCNetworkReachabilityRef)ref {	1✔
67	self = [super init];	1✔
68	if (self) {	1✔
69	_ref = ref;	1✔
70	}	1✔
71	return self;	1✔
72	}	1✔
73
74	- (instancetype) init {	×
75	struct sockaddr_in addr = {sizeof(addr), AF_INET}; // IP address 0.0.0.0	×
76	SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithAddress(NULL,	×
77	(struct sockaddr*)&addr);	×
78	return [self initWithReachabilityRef: ref];	×
79	}	×
80
81	- (instancetype) initWithURL: (NSURL*)url {	1✔
82	NSString* hostName = url.host;	1✔
83	if (!hostName.length)	1✔
84	hostName = @"localhost";	×
85	// If network access requires a proxy, just track whether there is any network connection:	1✔
86	if ([[self class] usingProxyForURL: url]) {	1✔
87	self = [self init];	×
88	if (self)	×
89	_usingProxy = YES;	×
90	} else {	1✔
91	self = [self initWithReachabilityRef: SCNetworkReachabilityCreateWithName(NULL,	1✔
92	hostName.UTF8String)];	1✔
93	}	1✔
94	if (self) {	1✔
95	_hostName = [hostName copy];	1✔
96	}	1✔
97	return self;	1✔
98	}	1✔
99
100	- (BOOL) setupCallback {	1✔
101	SCNetworkReachabilityContext context = {0, (__bridge void *)(self)};	1✔
102	return _ref && SCNetworkReachabilitySetCallback(_ref, ClientCallback, &context);	1✔
103	}	1✔
104
105	- (BOOL) removeCallback {	2✔
106	return _ref && SCNetworkReachabilitySetCallback(_ref, NULL, NULL);	2✔
107	}	2✔
108
109	- (BOOL) startOnRunLoop: (CFRunLoopRef)runLoop {	×
110	if (_runLoop \|\| _queue)	×
111	return (_runLoop == runLoop);	×
112	if (![self setupCallback])	×
113	return NO;	×
114	if (!SCNetworkReachabilityScheduleWithRunLoop(_ref, runLoop, kCFRunLoopCommonModes))	×
115	return NO;	×
116	_runLoop = (CFRunLoopRef) CFRetain(runLoop);	×
117	return [self started];	×
118	}	×
119
120	- (BOOL) startOnQueue: (dispatch_queue_t)queue {	1✔
121	if (_runLoop \|\| _queue)	1✔
122	return _queue == queue;	×
123	if (![self setupCallback])	1✔
124	return NO;	×
125	if (!SCNetworkReachabilitySetDispatchQueue(_ref, queue))	1✔
126	return NO;	×
127	_queue = queue;	1✔
128	return [self started];	1✔
129	}	1✔
130
131	- (BOOL) started {	1✔
132	// See whether status is already known:	1✔
133	SCNetworkReachabilityFlags flag;	1✔
134	if (SCNetworkReachabilityGetFlags(_ref, &flag)) {	1✔
135	CBLLogInfo(Sync, @"%@: flags=%x; starting...", self, flag);	1✔
136	[self notifyFlagsChanged: flag];	1✔
137	} else {	1✔
138	CBLLogInfo(Sync, @"%@: starting...", self);	×
139	}	×
140	return YES;	1✔
141	}	1✔
142
143	- (void) notifyFlagsChanged: (SCNetworkReachabilityFlags)flags {	1✔
144	if (_queue) {	1✔
145	dispatch_async(_queue, ^{	1✔
146	[self flagsChanged: flags];	1✔
147	});	1✔
148	} else {	1✔
149	Assert(_runLoop);	×
150	CFRunLoopPerformBlock(_runLoop, kCFRunLoopCommonModes, ^{	×
151	[self flagsChanged: flags];	×
152	});	×
153	}	×
154	}	1✔
155
156	- (void) stop {	2✔
157	_reachabilityKnown = NO;	2✔
158	if (_runLoop \|\| _queue)	2✔
159	CBLLogInfo(Sync, @"%@: stopped", self);	2✔
160		2✔
161	if (![self removeCallback])	2✔
162	CBLWarn(Sync, @"%@: cannot remove reachability callback", self);	2✔
163		2✔
164	if (_runLoop) {	2✔
165	SCNetworkReachabilityUnscheduleFromRunLoop(_ref, _runLoop, kCFRunLoopCommonModes);	×
166	CFRelease(_runLoop);	×
167	_runLoop = NULL;	×
168	}	×
169	if (_queue) {	2✔
170	SCNetworkReachabilitySetDispatchQueue(_ref, NULL);	1✔
171	_queue = NULL;	1✔
172	}	1✔
173	}	2✔
174
175	- (void)dealloc {	1✔
176	if (_ref) {	1✔
177	[self stop];	1✔
178	CFRelease(_ref);	1✔
179	}	1✔
180	}	1✔
181
182	- (NSString*) status {	×
183	if (!self.reachable)	×
184	return @"unreachable";	×
185	#if TARGET_OS_IPHONE	×
186	else if (!self.reachableByWiFi)	×
187	return @"reachable (3G)";	×
188	#endif	×
189	else	×
190	return @"reachable";	×
191	}	×
192
193	- (NSString*) description {	3✔
194	NSString* desc;	3✔
195	if (!_hostName)	3✔
196	desc = @"Reachability<(any)>";	×
197	else if (_usingProxy)	3✔
198	desc = $sprintf(@"Reachability<(proxy to)%@>", _hostName);	×
199	else	3✔
200	desc = $sprintf(@"Reachability<%@>", _hostName);	3✔
201	return desc;	3✔
202	}	3✔
203
204	- (BOOL) reachable {	1✔
205	// We want 'reachable' flag to be on, but not if user intervention is required (like PPP login)	1✔
206	SCNetworkReachabilityFlags flags;	1✔
207	if (_reachabilityKnown)	1✔
208	flags = _reachabilityFlags;	1✔
209	else if (!SCNetworkReachabilityGetFlags(_ref, &flags))	×
210	return false;	×
211		1✔
212	return (flags & kSCNetworkReachabilityFlagsReachable) && !(flags & kSCNetworkReachabilityFlagsInterventionRequired);	1✔
213	}	1✔
214
215	- (BOOL) reachableByWiFi {	×
216	return self.reachable	×
217	#if TARGET_OS_IPHONE	×
218	&& !(_reachabilityFlags & kSCNetworkReachabilityFlagsIsWWAN)	×
219	#endif	×
220	;	×
221	}	×
222
223	+ (NSSet*) keyPathsForValuesAffectingReachable {	×
224	return [NSSet setWithObjects: @"reachabilityKnown", @"reachabilityFlags", nil];	×
225	}	×
226
227	+ (NSSet*) keyPathsForValuesAffectingReachableByWiFi {	×
228	return [NSSet setWithObjects: @"reachabilityKnown", @"reachabilityFlags", nil];	×
229	}	×
230
231	- (void) flagsChanged: (SCNetworkReachabilityFlags)flags {	1✔
232	if (!_reachabilityKnown \|\| flags != _reachabilityFlags) {	1✔
233	self.reachabilityFlags = flags;	1✔
234	self.reachabilityKnown = YES;	1✔
235	CBLLogInfo(Sync, @"%@: flags <-- %x", self, flags);	1✔
236	__typeof(_onChange) onChange = _onChange;	1✔
237	if (onChange)	1✔
238	onChange();	1✔
239	}	1✔
240	}	1✔
241
242	static void ClientCallback(SCNetworkReachabilityRef target,
243	SCNetworkReachabilityFlags flags,
244	void *info)
245	{	×
246	[(__bridge CBLReachability*)info flagsChanged: flags];	×
247	}	×
248
249	@end

couchbase / couchbase-lite-ios / 943

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous