def refreshManualConnections(self): manualConnections = self.getManualConnections() if not manualConnections: return util.LOG("Refreshing {0} manual connections".format( len(manualConnections))) for conn in manualConnections: # Default to http, as the server will need to be signed in for https to work, # so the client should too. We'd also have to allow hostname entry, instead of # IP address for the cert to validate. proto = "http" port = conn.port or "32400" serverAddress = "{0}://{1}:{2}".format(proto, conn.connection, port) request = http.HttpRequest(serverAddress + "/identity") context = request.createRequestContext( "manual_connections", callback.Callable(self.onManualConnectionsResponse)) context.serverAddress = serverAddress context.address = conn.connection context.proto = proto context.port = port context.timeout = 10000 plexapp.APP.startRequest(request, context)
def buildTranscodeMkv(self, obj): util.DEBUG_LOG('buildTranscodeMkv()') obj.streamFormat = "mkv" obj.streamBitrates = [0] obj.transcodeEndpoint = "/video/:/transcode/universal/start.mkv" builder = http.HttpRequest(obj.transcodeServer.buildUrl(obj.transcodeEndpoint, True)) builder.extras = [] # builder.addParam("protocol", "http") builder.addParam("copyts", "1") obj.subtitleUrl = None if True: # if self.choice.subtitleDecision == self.choice.SUBTITLES_BURN: # Must burn transcoded because we can't set offset builder.addParam("subtitles", "burn") captionSize = captions.CAPTIONS.getBurnedSize() if captionSize is not None: builder.addParam("subtitleSize", captionSize) else: # TODO(rob): can we safely assume the id will also be 3 (one based index). # If not, we will have to get tricky and select the subtitle stream after # video playback starts via roCaptionRenderer: GetSubtitleTracks() and # ChangeSubtitleTrack() obj.subtitleConfig = {'TrackName': "mkv/3"} # Allow text conversion of subtitles if we only burn image formats if self.item.settings.getPreference("burn_subtitles") == "image": builder.addParam("advancedSubtitles", "text") builder.addParam("subtitles", "auto") # Augment the server's profile for things that depend on the Roku's configuration. if self.item.settings.supportsSurroundSound(): if self.choice.audioStream is not None: numChannels = self.choice.audioStream.channels.asInt(6) else: numChannels = 6 for codec in ("ac3", "eac3", "dca"): if self.item.settings.supportsAudioStream(codec, numChannels): builder.extras.append("append-transcode-target-audio-codec(type=videoProfile&context=streaming&audioCodec=" + codec + ")") builder.extras.append("add-direct-play-profile(type=videoProfile&container=matroska&videoCodec=*&audioCodec=" + codec + ")") if codec == "dca": builder.extras.append( "add-limitation(scope=videoAudioCodec&scopeName=dca&type=upperBound&name=audio.channels&value=6&isRequired=false)" ) # AAC sample rate cannot be less than 22050hz (HLS is capable). if self.choice.audioStream is not None and self.choice.audioStream.samplingRate.asInt(22050) < 22050: builder.extras.append("add-limitation(scope=videoAudioCodec&scopeName=aac&type=lowerBound&name=audio.samplingRate&value=22050&isRequired=false)") # HEVC and VP9 support! if self.item.settings.getGlobal("hevcSupport"): builder.extras.append("append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=hevc)") if self.item.settings.getGlobal("vp9Support"): builder.extras.append("append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=vp9)") return builder
def buildTranscodeHls(self, obj): util.DEBUG_LOG('buildTranscodeHls()') obj.streamFormat = "hls" obj.streamBitrates = [0] obj.switchingStrategy = "no-adaptation" obj.transcodeEndpoint = "/video/:/transcode/universal/start.m3u8" builder = http.HttpRequest( obj.transcodeServer.buildUrl(obj.transcodeEndpoint, True)) builder.extras = [] builder.addParam("protocol", "hls") if self.choice.subtitleDecision == self.choice.SUBTITLES_SOFT_ANY: builder.addParam("skipSubtitles", "1") else: # elif self.choice.hasBurnedInSubtitles is True: # Must burn transcoded because we can't set offset captionSize = captions.CAPTIONS.getBurnedSize() if captionSize is not None: builder.addParam("subtitleSize", captionSize) # Augment the server's profile for things that depend on the Roku's configuration. if self.item.settings.supportsAudioStream("ac3", 6): builder.extras.append( "append-transcode-target-audio-codec(type=videoProfile&context=streaming&protocol=hls&audioCodec=ac3)" ) builder.extras.append( "add-direct-play-profile(type=videoProfile&container=matroska&videoCodec=*&audioCodec=ac3)" ) return builder
def testReachability(self, server, allowFallback=False): # Check if we will allow the connection test. If this is a fallback connection, # then we will defer it until we "allowFallback" (test insecure connections # after secure tests have completed and failed). Insecure connections will be # tested if the policy "always" allows them, or if set to "same_network" and # the current connection is local and server has (publicAddressMatches=1). allowConnectionTest = not self.isFallback if not allowConnectionTest: insecurePolicy = plexapp.INTERFACE.getPreference("allow_insecure") if insecurePolicy == "always" or (insecurePolicy == "same_network" and server.sameNetwork and self.isLocal): allowConnectionTest = allowFallback server.hasFallback = not allowConnectionTest util.LOG('{0} for {1}'.format( allowConnectionTest and "Continuing with insecure connection testing" or "Insecure connection testing is deferred", server)) else: util.LOG( "Insecure connections not allowed. Ignore insecure connection test for {0}" .format(server)) self.state = self.STATE_INSECURE callable = callback.Callable(server.onReachabilityResult, [self], random.randint(0, 256)) callable.deferCall() return True if allowConnectionTest: if not self.isSecure and ( not allowFallback and server.hasSecureConnections() or server.activeConnection and server.activeConnection.state != self.STATE_REACHABLE and server.activeConnection.isSecure): util.DEBUG_LOG("Invalid insecure connection test in progress") self.request = http.HttpRequest(self.buildUrl(server, "/")) context = self.request.createRequestContext( "reachability", callback.Callable(self.onReachabilityResponse)) context.server = server context.timeout = 10000 util.addPlexHeaders(self.request, server.getToken()) self.hasPendingRequest = plexapp.APP.startRequest( self.request, context) return True return False
def __init__(self): self.symbols = {} # Create dummy objects for completion self.symbols['coal'] = CoalRecordGpb() self.symbols['msgData'] = MsgDataGpb() self.symbols['transaction'] = TransactionSummaryGpb() self.symbols['request'] = http.HttpRequest("GET / HTTP/1.1\r\n\r\n") self.symbols['response'] = http.HttpResponse("HTTP/1.1 200 OK\r\n\r\n") self.symbols['uri'] = http.Uri("http://host:80/path?var=value") runtimeNS = __import__('runtime', globals()) self.symbols['runtime'] = runtimeNS for moduleName, moduleHandle in statements.importMap.iteritems(): if moduleHandle: self.symbols[moduleName] = moduleHandle rlcompleter.Completer.__init__(self, self.symbols) self.noMore = False self.parentState = 0 self.matchedVars = []
def buildTranscode(self, obj): transcodeServer = self.item.getTranscodeServer(True, "audio") if not transcodeServer: return None obj.streamFormat = "mp3" obj.isTranscoded = True obj.transcodeServer = transcodeServer builder = http.HttpRequest(transcodeServer.buildUrl("/music/:/transcode/universal/start.m3u8", True)) builder.addParam("protocol", "http") builder.addParam("path", self.item.getAbsolutePath("key")) builder.addParam("session", self.item.getGlobal("clientIdentifier")) builder.addParam("directPlay", "0") builder.addParam("directStream", "0") obj.url = builder.getUrl() return obj
def get_http_request(self, service): return (http.HttpRequest(service.get_request_path("departureBoard")) .add_param(id=self.id) .add_param(date=self.get_date()) .add_param(time=self.get_time()))
def create_request(request): client_socket = tests.fakes.FakeClientSocket(request) req = http.HttpRequest(client_socket) return req
def get_http_request(self, service): return (http.HttpRequest(service.get_request_path("location")) .add_param(input=self.input))
def get_http_request(self, service): return http.HttpRequest(self.url)
def resolveIndirect(self): if not self.isIndirect() or locks.LOCKS.isLocked("resolve_indirect"): return self part = self.parts[0] if part is None: util.DEBUG("Failed to resolve indirect media: missing valid part") return None postBody = None postUrl = part.postURL request = plexrequest.PlexRequest( self.getServer(), part.key, postUrl is not None and "POST" or "GET") if postUrl is not None: util.DEBUG( "Fetching content for indirect media POST URL: {0}".format( postUrl)) # Force setting the certificate to handle following https redirects postRequest = http.HttpRequest(postUrl, None, True) postResponse = postRequest.getToStringWithTimeout(30) if len(postResponse) > 0 and type( postRequest.event) == "roUrlEvent": util.DEBUG( "Retrieved data from postURL, posting to resolve container" ) crlf = chr(13) + chr(10) postBody = "" for header in postRequest.event.getResponseHeadersArray(): for name in header: postBody = postBody + name + ": " + header[name] + crlf postBody = postBody + crlf + postResponse else: util.DEBUG("Failed to resolve indirect media postUrl") self.Set("indirect", "-1") return self request.addParam("postURL", postUrl) response = request.doRequestWithTimeout(30, postBody) item = response.items[0] if item is None or item.mediaItems[0] is None: util.DEBUG("Failed to resolve indirect media: no media items") self.indirect = -1 return self media = item.mediaItems[0] # Add indirect headers to the media item media.indirectHeaders = util.AttributeDict() for header in (item.container.httpHeaders or '').split("&"): arr = header.split("=") if len(arr) == 2: media.indirectHeaders[arr[0]] = arr[1] # Reset the fallback media id if applicable if self.id.asInt() < 0: media.id = self.id return media.resolveIndirect()
def dispatch_client_requests(self): client_socket, addr = self.listener_socket.accept() req = http.HttpRequest(client_socket) resp = http.HttpResponse(client_socket) self.client_request_router(req, resp)
def __init__(self): self.req = http.HttpRequest()