This hydrus client uses software version ''' + str( HC.SOFTWARE_VERSION ) + ''' and network version ''' + str( HC.NETWORK_VERSION ) + '''.
It only serves requests from 127.0.0.1.
''' ROOT_MESSAGE_BEGIN = '''This hydrus service uses software version ''' + str( HC.SOFTWARE_VERSION ) + ''' and network version ''' + str( HC.NETWORK_VERSION ) + '''.
''' ROOT_MESSAGE_END = '''
''' def ParseFileArguments( path ): HydrusImageHandling.ConvertToPngIfBmp( path ) hash = HydrusFileHandling.GetHashFromPath( path ) try: ( size, mime, width, height, duration, num_frames, num_words ) = HydrusFileHandling.GetFileInfo( path ) except HydrusExceptions.SizeException: raise HydrusExceptions.ForbiddenException( 'File is of zero length!' ) except HydrusExceptions.MimeException: raise HydrusExceptions.ForbiddenException( 'Filetype is not permitted!' ) except Exception as e: raise HydrusExceptions.ForbiddenException( HydrusData.ToUnicode( e ) ) args = {} args[ 'path' ] = path args[ 'hash' ] = hash args[ 'size' ] = size args[ 'mime' ] = mime if width is not None: args[ 'width' ] = width if height is not None: args[ 'height' ] = height if duration is not None: args[ 'duration' ] = duration if num_frames is not None: args[ 'num_frames' ] = num_frames if num_words is not None: args[ 'num_words' ] = num_words if mime in HC.MIMES_WITH_THUMBNAILS: try: thumbnail = HydrusFileHandling.GenerateThumbnail( path ) except: raise HydrusExceptions.ForbiddenException( 'Could not generate thumbnail from that file.' ) args[ 'thumbnail' ] = thumbnail return args hydrus_favicon = FileResource( os.path.join( HC.STATIC_DIR, 'hydrus.ico' ), defaultType = 'image/x-icon' ) local_booru_css = FileResource( os.path.join( HC.STATIC_DIR, 'local_booru_style.css' ), defaultType = 'text/css' ) class HydrusDomain( object ): def __init__( self, local_only ): self._local_only = local_only def CheckValid( self, client_ip ): if self._local_only and client_ip != '127.0.0.1': raise HydrusExceptions.ForbiddenException( 'Only local access allowed!' ) class HydrusResourceBusyCheck( Resource ): def __init__( self ): Resource.__init__( self ) self._server_version_string = HC.service_string_lookup[ HC.SERVER_ADMIN ] + '/' + str( HC.NETWORK_VERSION ) def render_GET( self, request ): request.setHeader( 'Server', self._server_version_string ) if HydrusGlobals.server_busy: return '1' else: return '0' class HydrusResourceWelcome( Resource ): def __init__( self, service_type, message ): Resource.__init__( self ) if service_type == HC.LOCAL_FILE: body = CLIENT_ROOT_MESSAGE else: body = ROOT_MESSAGE_BEGIN + message + ROOT_MESSAGE_END self._body = HydrusData.ToByteString( body ) self._server_version_string = HC.service_string_lookup[ service_type ] + '/' + str( HC.NETWORK_VERSION ) def render_GET( self, request ): request.setHeader( 'Server', self._server_version_string ) return self._body class HydrusResourceCommand( Resource ): def __init__( self, service_key, service_type, domain ): Resource.__init__( self ) self._service_key = service_key self._service_type = service_type self._domain = domain self._server_version_string = HC.service_string_lookup[ service_type ] + '/' + str( HC.NETWORK_VERSION ) def _checkServerBusy( self ): if HydrusGlobals.server_busy: raise HydrusExceptions.ServerBusyException( 'This server is busy, please try again later.' ) def _callbackCheckRestrictions( self, request ): self._checkServerBusy() self._checkUserAgent( request ) self._domain.CheckValid( request.getClientIP() ) return request def _callbackParseGETArgs( self, request ): hydrus_args = {} for name in request.args: values = request.args[ name ] value = values[0] if name in ( 'begin', 'expires', 'lifetime', 'num', 'service_type', 'service_port', 'since', 'subindex', 'timespan' ): try: hydrus_args[ name ] = int( value ) except: raise HydrusExceptions.ForbiddenException( 'I was expecting to parse \'' + name + '\' as an integer, but it failed.' ) elif name in ( 'access_key', 'title', 'subject_account_key', 'contact_key', 'hash', 'subject_hash', 'subject_tag', 'message_key', 'share_key' ): try: hydrus_args[ name ] = value.decode( 'hex' ) except: raise HydrusExceptions.ForbiddenException( 'I was expecting to parse \'' + name + '\' as a hex-encoded string, but it failed.' ) if 'subject_account_key' in hydrus_args: hydrus_args[ 'subject_identifier' ] = HydrusData.AccountIdentifier( account_key = hydrus_args[ 'subject_account_key' ] ) elif 'subject_hash' in hydrus_args: hash = hydrus_args[ 'subject_hash' ] if 'subject_tag' in hydrus_args: tag = hydrus_args[ 'subject_tag' ] content = HydrusData.Content( HC.CONTENT_TYPE_MAPPING, ( tag, hash ) ) else: content = HydrusData.Content( HC.CONTENT_TYPE_FILES, [ hash ] ) hydrus_args[ 'subject_identifier' ] = HydrusData.AccountIdentifier( content = content ) request.hydrus_args = hydrus_args return request def _callbackParsePOSTArgs( self, request ): request.content.seek( 0 ) if not request.requestHeaders.hasHeader( 'Content-Type' ): hydrus_args = {} else: content_types = request.requestHeaders.getRawHeaders( 'Content-Type' ) content_type = content_types[0] try: mime = HC.mime_enum_lookup[ content_type ] except: raise HydrusExceptions.ForbiddenException( 'Did not recognise Content-Type header!' ) if mime == HC.APPLICATION_YAML: yaml_string = request.content.read() request.hydrus_request_data_usage += len( yaml_string ) hydrus_args = yaml.safe_load( yaml_string ) elif mime == HC.APPLICATION_JSON: json_string = request.content.read() request.hydrus_request_data_usage += len( json_string ) hydrus_args = HydrusSerialisable.CreateFromNetworkString( json_string ) else: ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath() request.temp_file_info = ( os_file_handle, temp_path ) with open( temp_path, 'wb' ) as f: for block in HydrusPaths.ReadFileLikeAsBlocks( request.content ): f.write( block ) request.hydrus_request_data_usage += len( block ) hydrus_args = ParseFileArguments( temp_path ) request.hydrus_args = hydrus_args return request def _callbackRenderResponseContext( self, request ): self._CleanUpTempFile( request ) response_context = request.hydrus_response_context status_code = response_context.GetStatusCode() request.setResponseCode( status_code ) for ( k, v, kwargs ) in response_context.GetCookies(): request.addCookie( k, v, **kwargs ) do_finish = True if response_context.HasBody(): ( mime, body ) = response_context.GetMimeBody() content_type = HC.mime_string_lookup[ mime ] content_length = len( body ) request.setHeader( 'Content-Type', content_type ) request.setHeader( 'Content-Length', str( content_length ) ) request.write( HydrusData.ToByteString( body ) ) elif response_context.HasPath(): path = response_context.GetPath() info = os.lstat( path ) size = info[6] if response_context.IsJSON(): mime = HC.APPLICATION_JSON content_type = HC.mime_string_lookup[ mime ] else: mime = HydrusFileHandling.GetMime( path ) ( base, filename ) = os.path.split( path ) content_type = HC.mime_string_lookup[ mime ] + '; ' + filename content_length = size # can't be unicode! request.setHeader( 'Content-Type', str( content_type ) ) request.setHeader( 'Content-Length', str( content_length ) ) request.setHeader( 'Expires', time.strftime( '%a, %d %b %Y %H:%M:%S GMT', time.gmtime( time.time() + 86400 * 365 ) ) ) request.setHeader( 'Cache-Control', str( 86400 * 365 ) ) fileObject = open( path, 'rb' ) producer = NoRangeStaticProducer( request, fileObject ) producer.start() do_finish = False else: content_length = 0 request.setHeader( 'Content-Length', str( content_length ) ) request.hydrus_request_data_usage += content_length self._recordDataUsage( request ) if do_finish: request.finish() def _callbackDoGETJob( self, request ): def wrap_thread_result( response_context ): request.hydrus_response_context = response_context return request d = deferToThread( self._threadDoGETJob, request ) d.addCallback( wrap_thread_result ) return d def _callbackDoPOSTJob( self, request ): def wrap_thread_result( response_context ): request.hydrus_response_context = response_context return request d = deferToThread( self._threadDoPOSTJob, request ) d.addCallback( wrap_thread_result ) return d def _checkUserAgent( self, request ): request.is_hydrus_user_agent = False if request.requestHeaders.hasHeader( 'User-Agent' ): user_agent_texts = request.requestHeaders.getRawHeaders( 'User-Agent' ) user_agent_text = user_agent_texts[0] try: user_agents = user_agent_text.split( ' ' ) except: return # crazy user agent string, so just assume not a hydrus client for user_agent in user_agents: if '/' in user_agent: ( client, network_version ) = user_agent.split( '/', 1 ) if client == 'hydrus': request.is_hydrus_user_agent = True network_version = int( network_version ) if network_version == HC.NETWORK_VERSION: return else: if network_version < HC.NETWORK_VERSION: message = 'Your client is out of date; please download the latest release.' else: message = 'This server is out of date; please ask its admin to update to the latest release.' raise HydrusExceptions.NetworkVersionException( 'Network version mismatch! This server\'s network version is ' + str( HC.NETWORK_VERSION ) + ', whereas your client\'s is ' + str( network_version ) + '! ' + message ) def _errbackDisconnected( self, failure, request_deferred ): request_deferred.cancel() def _errbackHandleEmergencyError( self, failure, request ): try: self._CleanUpTempFile( request ) except: pass try: HydrusData.DebugPrint( failure.getTraceback() ) except: pass try: request.write( failure.getTraceback() ) except: pass try: request.finish() except: pass def _errbackHandleProcessingError( self, failure, request ): self._CleanUpTempFile( request ) do_yaml = True try: # the error may have occured before user agent was set up! if not request.is_hydrus_user_agent: do_yaml = False except: pass if do_yaml: default_mime = HC.APPLICATION_YAML default_encoding = lambda x: yaml.safe_dump( HydrusData.ToUnicode( x ) ) else: default_mime = HC.TEXT_HTML default_encoding = lambda x: HydrusData.ToByteString( x ) if failure.type == KeyError: response_context = ResponseContext( 403, mime = default_mime, body = default_encoding( 'It appears one or more parameters required for that request were missing:' + os.linesep + failure.getTraceback() ) ) elif failure.type == HydrusExceptions.PermissionException: response_context = ResponseContext( 401, mime = default_mime, body = default_encoding( failure.value ) ) elif failure.type == HydrusExceptions.ForbiddenException: response_context = ResponseContext( 403, mime = default_mime, body = default_encoding( failure.value ) ) elif failure.type == HydrusExceptions.NotFoundException: response_context = ResponseContext( 404, mime = default_mime, body = default_encoding( failure.value ) ) elif failure.type == HydrusExceptions.NetworkVersionException: response_context = ResponseContext( 426, mime = default_mime, body = default_encoding( failure.value ) ) elif failure.type == HydrusExceptions.ServerBusyException: response_context = ResponseContext( 503, mime = default_mime, body = default_encoding( failure.value ) ) elif failure.type == HydrusExceptions.SessionException: response_context = ResponseContext( 419, mime = default_mime, body = default_encoding( failure.value ) ) else: HydrusData.DebugPrint( failure.getTraceback() ) response_context = ResponseContext( 500, mime = default_mime, body = default_encoding( 'The repository encountered an error it could not handle! Here is a dump of what happened, which will also be written to your client.log file. If it persists, please forward it to hydrus.admin@gmail.com:' + os.linesep * 2 + failure.getTraceback() ) ) request.hydrus_response_context = response_context return request def _parseAccessKey( self, request ): if not request.requestHeaders.hasHeader( 'Hydrus-Key' ): raise HydrusExceptions.PermissionException( 'No hydrus key header found!' ) hex_keys = request.requestHeaders.getRawHeaders( 'Hydrus-Key' ) hex_key = hex_keys[0] try: access_key = hex_key.decode( 'hex' ) except: raise HydrusExceptions.ForbiddenException( 'Could not parse the hydrus key!' ) return access_key def _recordDataUsage( self, request ): pass def _threadDoGETJob( self, request ): raise HydrusExceptions.NotFoundException( 'This service does not support that request!' ) def _threadDoPOSTJob( self, request ): raise HydrusExceptions.NotFoundException( 'This service does not support that request!' ) def _CleanUpTempFile( self, request ): if hasattr( request, 'temp_file_info' ): ( os_file_handle, temp_path ) = request.temp_file_info HydrusPaths.CleanUpTempPath( os_file_handle, temp_path ) del request.temp_file_info def render_GET( self, request ): request.setHeader( 'Server', self._server_version_string ) d = defer.Deferred() d.addCallback( self._callbackCheckRestrictions ) d.addCallback( self._callbackParseGETArgs ) d.addCallback( self._callbackDoGETJob ) d.addErrback( self._errbackHandleProcessingError, request ) d.addCallback( self._callbackRenderResponseContext ) d.addErrback( self._errbackHandleEmergencyError, request ) reactor.callLater( 0, d.callback, request ) request.notifyFinish().addErrback( self._errbackDisconnected, d ) return NOT_DONE_YET def render_POST( self, request ): request.setHeader( 'Server', self._server_version_string ) d = defer.Deferred() d.addCallback( self._callbackCheckRestrictions ) d.addCallback( self._callbackParsePOSTArgs ) d.addCallback( self._callbackDoPOSTJob ) d.addErrback( self._errbackHandleProcessingError, request ) d.addCallback( self._callbackRenderResponseContext ) d.addErrback( self._errbackHandleEmergencyError, request ) reactor.callLater( 0, d.callback, request ) request.notifyFinish().addErrback( self._errbackDisconnected, d ) return NOT_DONE_YET class HydrusResourceCommandAccessKey( HydrusResourceCommand ): def _threadDoGETJob( self, request ): registration_key = self._parseAccessKey( request ) access_key = HydrusGlobals.controller.Read( 'access_key', registration_key ) body = yaml.safe_dump( { 'access_key' : access_key } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandShutdown( HydrusResourceCommand ): def _threadDoPOSTJob( self, request ): HydrusGlobals.controller.ShutdownFromServer() response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandAccessKeyVerification( HydrusResourceCommand ): def _threadDoGETJob( self, request ): access_key = self._parseAccessKey( request ) verified = HydrusGlobals.controller.Read( 'verify_access_key', self._service_key, access_key ) body = yaml.safe_dump( { 'verified' : verified } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandInit( HydrusResourceCommand ): def _threadDoGETJob( self, request ): access_key = HydrusGlobals.controller.Read( 'init' ) body = yaml.safe_dump( { 'access_key' : access_key } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandSessionKey( HydrusResourceCommand ): def _threadDoGETJob( self, request ): access_key = self._parseAccessKey( request ) session_manager = HydrusGlobals.controller.GetManager( 'restricted_services_sessions' ) ( session_key, expires ) = session_manager.AddSession( self._service_key, access_key ) now = HydrusData.GetNow() max_age = now - expires cookies = [ ( 'session_key', session_key.encode( 'hex' ), { 'max_age' : max_age, 'path' : '/' } ) ] response_context = ResponseContext( 200, cookies = cookies ) return response_context class HydrusResourceCommandRestricted( HydrusResourceCommand ): GET_PERMISSION = HC.GENERAL_ADMIN POST_PERMISSION = HC.GENERAL_ADMIN def _callbackCheckRestrictions( self, request ): self._checkServerBusy() self._checkUserAgent( request ) self._domain.CheckValid( request.getClientIP() ) self._checkSession( request ) self._checkPermission( request ) return request def _checkPermission( self, request ): account = request.hydrus_account method = request.method permission = None if method == 'GET': permission = self.GET_PERMISSION elif method == 'POST': permission = self.POST_PERMISSION if permission is not None: account.CheckPermission( permission ) return request def _checkSession( self, request ): if not request.requestHeaders.hasHeader( 'Cookie' ): raise HydrusExceptions.PermissionException( 'No cookies found!' ) cookie_texts = request.requestHeaders.getRawHeaders( 'Cookie' ) cookie_text = cookie_texts[0] try: cookies = Cookie.SimpleCookie( cookie_text ) if 'session_key' not in cookies: session_key = None else: session_key = cookies[ 'session_key' ].value.decode( 'hex' ) except: raise Exception( 'Problem parsing cookies!' ) session_manager = HydrusGlobals.controller.GetManager( 'restricted_services_sessions' ) account = session_manager.GetAccount( self._service_key, session_key ) request.hydrus_account = account return request def _recordDataUsage( self, request ): path = request.path[1:] # /account -> account if request.method == 'GET': method = HC.GET else: method = HC.POST if ( self._service_type, method, path ) in HC.BANDWIDTH_CONSUMING_REQUESTS: account = request.hydrus_account if account is not None: num_bytes = request.hydrus_request_data_usage account.RequestMade( num_bytes ) HydrusGlobals.controller.pub( 'request_made', ( account.GetAccountKey(), num_bytes ) ) class HydrusResourceCommandRestrictedAccount( HydrusResourceCommandRestricted ): GET_PERMISSION = None POST_PERMISSION = HC.MANAGE_USERS def _threadDoGETJob( self, request ): account = request.hydrus_account body = yaml.safe_dump( { 'account' : account } ) response_context = ResponseContext( 200, body = body ) return response_context def _threadDoPOSTJob( self, request ): admin_account = request.hydrus_account admin_account_key = admin_account.GetAccountKey() action = request.hydrus_args[ 'action' ] subject_identifiers = request.hydrus_args[ 'subject_identifiers' ] subject_account_keys = { HydrusGlobals.controller.Read( 'account_key_from_identifier', self._service_key, subject_identifier ) for subject_identifier in subject_identifiers } kwargs = request.hydrus_args # for things like expires, title, and so on HydrusGlobals.controller.WriteSynchronous( 'account', self._service_key, admin_account_key, action, subject_account_keys, kwargs ) session_manager = HydrusGlobals.controller.GetManager( 'restricted_services_sessions' ) session_manager.RefreshAccounts( self._service_key, subject_account_keys ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedAccountInfo( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): subject_identifier = request.hydrus_args[ 'subject_identifier' ] subject_account_key = HydrusGlobals.controller.Read( 'account_key_from_identifier', self._service_key, subject_identifier ) account_info = HydrusGlobals.controller.Read( 'account_info', self._service_key, subject_account_key ) body = yaml.safe_dump( { 'account_info' : account_info } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedAccountTypes( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN POST_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): account_types = HydrusGlobals.controller.Read( 'account_types', self._service_key ) body = yaml.safe_dump( { 'account_types' : account_types } ) response_context = ResponseContext( 200, body = body ) return response_context def _threadDoPOSTJob( self, request ): edit_log = request.hydrus_args[ 'edit_log' ] HydrusGlobals.controller.WriteSynchronous( 'account_types', self._service_key, edit_log ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedBackup( HydrusResourceCommandRestricted ): POST_PERMISSION = HC.GENERAL_ADMIN def _threadDoPOSTJob( self, request ): def do_it(): HydrusGlobals.server_busy = True HydrusGlobals.controller.WriteSynchronous( 'backup' ) HydrusGlobals.server_busy = False HydrusGlobals.controller.CallToThread( do_it ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedIP( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): hash = request.hydrus_args[ 'hash' ] ( ip, timestamp ) = HydrusGlobals.controller.Read( 'ip', self._service_key, hash ) body = yaml.safe_dump( { 'ip' : ip, 'timestamp' : timestamp } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedNews( HydrusResourceCommandRestricted ): POST_PERMISSION = HC.GENERAL_ADMIN def _threadDoPOSTJob( self, request ): news = request.hydrus_args[ 'news' ] HydrusGlobals.controller.WriteSynchronous( 'news', self._service_key, news ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedNumPetitions( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.RESOLVE_PETITIONS def _threadDoGETJob( self, request ): num_petitions = HydrusGlobals.controller.Read( 'num_petitions', self._service_key ) body = yaml.safe_dump( { 'num_petitions' : num_petitions } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedPetition( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.RESOLVE_PETITIONS def _threadDoGETJob( self, request ): petition = HydrusGlobals.controller.Read( 'petition', self._service_key ) body = petition.DumpToNetworkString() response_context = ResponseContext( 200, mime = HC.APPLICATION_JSON, body = body ) return response_context class HydrusResourceCommandRestrictedRegistrationKeys( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): num = request.hydrus_args[ 'num' ] title = request.hydrus_args[ 'title' ] if 'lifetime' in request.hydrus_args: lifetime = request.hydrus_args[ 'lifetime' ] else: lifetime = None registration_keys = HydrusGlobals.controller.Read( 'registration_keys', self._service_key, num, title, lifetime ) body = yaml.safe_dump( { 'registration_keys' : registration_keys } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedRepositoryFile( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GET_DATA POST_PERMISSION = HC.POST_DATA def _threadDoGETJob( self, request ): hash = request.hydrus_args[ 'hash' ] # don't I need to check that we aren't stealing the file from another service? path = ServerFiles.GetPath( 'file', hash ) response_context = ResponseContext( 200, path = path ) return response_context def _threadDoPOSTJob( self, request ): account = request.hydrus_account account_key = account.GetAccountKey() file_dict = request.hydrus_args file_dict[ 'ip' ] = request.getClientIP() HydrusGlobals.controller.WriteSynchronous( 'file', self._service_key, account_key, file_dict ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedRepositoryThumbnail( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GET_DATA def _threadDoGETJob( self, request ): hash = request.hydrus_args[ 'hash' ] # don't I need to check that we aren't stealing the file from another service? path = ServerFiles.GetPath( 'thumbnail', hash ) response_context = ResponseContext( 200, path = path ) return response_context class HydrusResourceCommandRestrictedServices( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN POST_PERMISSION = HC.GENERAL_ADMIN def _threadDoPOSTJob( self, request ): account = request.hydrus_account account_key = account.GetAccountKey() edit_log = request.hydrus_args[ 'edit_log' ] service_keys_to_access_keys = HydrusGlobals.controller.WriteSynchronous( 'services', account_key, edit_log ) body = yaml.safe_dump( { 'service_keys_to_access_keys' : service_keys_to_access_keys } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedServicesInfo( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN POST_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): services_info = HydrusGlobals.controller.Read( 'services_info' ) body = yaml.safe_dump( { 'services_info' : services_info } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedStats( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GENERAL_ADMIN def _threadDoGETJob( self, request ): stats = HydrusGlobals.controller.Read( 'stats', self._service_key ) body = yaml.safe_dump( { 'stats' : stats } ) response_context = ResponseContext( 200, body = body ) return response_context class HydrusResourceCommandRestrictedContentUpdate( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GET_DATA POST_PERMISSION = HC.POST_DATA def _threadDoGETJob( self, request ): begin = request.hydrus_args[ 'begin' ] subindex = request.hydrus_args[ 'subindex' ] path = ServerFiles.GetContentUpdatePackagePath( self._service_key, begin, subindex ) response_context = ResponseContext( 200, path = path, is_json = True ) return response_context def _threadDoPOSTJob( self, request ): account = request.hydrus_account account_key = account.GetAccountKey() update = request.hydrus_args[ 'update' ] HydrusGlobals.controller.WriteSynchronous( 'update', self._service_key, account_key, update ) response_context = ResponseContext( 200 ) return response_context class HydrusResourceCommandRestrictedImmediateContentUpdate( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.RESOLVE_PETITIONS def _threadDoGETJob( self, request ): content_update = HydrusGlobals.controller.Read( 'immediate_content_update', self._service_key ) network_string = content_update.DumpToNetworkString() response_context = ResponseContext( 200, mime = HC.APPLICATION_JSON, body = network_string ) return response_context class HydrusResourceCommandRestrictedServiceUpdate( HydrusResourceCommandRestricted ): GET_PERMISSION = HC.GET_DATA def _threadDoGETJob( self, request ): begin = request.hydrus_args[ 'begin' ] path = ServerFiles.GetServiceUpdatePackagePath( self._service_key, begin ) response_context = ResponseContext( 200, path = path, is_json = True ) return response_context class ResponseContext( object ): def __init__( self, status_code, mime = HC.APPLICATION_YAML, body = None, path = None, is_json = False, cookies = None ): if cookies is None: cookies = [] self._status_code = status_code self._mime = mime self._body = body self._path = path self._is_json = is_json self._cookies = cookies def GetCookies( self ): return self._cookies def GetLength( self ): return len( self._body ) def GetMimeBody( self ): return ( self._mime, self._body ) def GetPath( self ): return self._path def GetStatusCode( self ): return self._status_code def HasBody( self ): return self._body is not None def HasPath( self ): return self._path is not None def IsJSON( self ): return self._is_json