Exemple #1
0
 def read_db():
     checker = FilePasswordDB('http.password',
                              delim=b'=',
                              hash=check_hashed_password)
     credentials = {}
     for user, password in checker._loadCredentials():
         credentials.update({user.decode(): password.decode()})
     return credentials
    def __init__(self, servicename):
        """
        @type servicename: str
        @param servicename: The name of the service which is using this database instance.

        """
        self.servicename = servicename
        self.filepath = str(Config.honeytoken.database_folder / "database-{}.txt".format(servicename))
        self.token_db = FilePasswordDB(self.filepath, delim=self.delimiter, cache=True)
        self.session_db = SessionDatabase()

        self.strategy = Config.honeytoken.strategy
Exemple #3
0
def run():
    parser = argparse.ArgumentParser(description='Manage OMS passwords')
    parser.add_argument('user', help="user name")
    parser.add_argument('-g',
                        help="group(s): comma separated list of "
                        "groups the user belongs to",
                        required=False,
                        default=None)
    parser.add_argument('-s',
                        action='store_true',
                        help="force password "
                        "prompt even if setting group(s) via -g",
                        required=False,
                        default=None)

    group = parser.add_mutually_exclusive_group()
    group.add_argument('-a', action='store_true', help="add user")
    group.add_argument('-d', action='store_true', help="delete user")
    group.add_argument('-c',
                       action='store_true',
                       help="check password, useful "
                       "to troubleshoot login issues")

    args = parser.parse_args()

    ensure_base_dir()
    passwd_file = get_config().get('auth', 'passwd_file')

    if not os.path.exists(passwd_file):
        with open(passwd_file, 'w'):
            pass

    try:
        if args.d:
            delete_user(args.user)
        elif args.a:
            add_user(args.user, ask_password(), group=args.g)
        elif args.c:
            password_checker = FilePasswordDB(passwd_file, hash=ssha_hash)
            credentials = UsernamePassword(args.user, getpass("Password: "******"Wrong credentials")

            print "ok"
        else:
            update_passwd(args.user, args.s, force=True)
    except UserManagementError as e:
        print e
        sys.exit(1)
Exemple #4
0
def resource():
    """Initialize the HTTP Authentication."""
    resthandle = RestIntf()
    realm = CheckRealm(resource=resthandle.app.resource())
    portal = Portal(realm, [FilePasswordDB('./server-auth.db')])
    credential_factory = BasicCredentialFactory(b"http auth realm")
    return HTTPAuthSessionWrapper(portal, [credential_factory])
Exemple #5
0
def run(device):
    '''
    Run a threaded server.
    '''
    prompts = {
        'rpi2': ':~$',
        'rpi3': ':~>'
    }
    this_dir = os.path.dirname(__file__)
    with open(os.path.join(this_dir, 'private.key')) as private_blob_file:
        private_blob = private_blob_file.read()
        private_key = Key.fromString(data=private_blob)

    with open(os.path.join(this_dir, 'public.key')) as public_blob_file:
        public_blob = public_blob_file.read()
        public_key = Key.fromString(data=public_blob)

    factory = SSHFactory()
    factory.privateKeys = {'ssh-rsa': private_key}
    factory.publicKeys = {'ssh-rsa': public_key}

    SimpleSession.set_prompt(prompts[device])
    factory.portal = Portal(SimpleRealm())
    factory.portal.registerChecker(FilePasswordDB(os.path.join(this_dir, 'ssh-passwords')))

    reactor.listenTCP(2022, factory, interface='127.0.0.1')
    thread = Thread(target=reactor.run, args=(False,))
    thread.daemon = True
    thread.start()
Exemple #6
0
 def __init__(self, port=21):
     self.portal = Portal(
         DPMFTPRealm(PATH_REPO),
         [AllowAnonymousAccess(),
          FilePasswordDB(PATH_ADMIN)])
     self.factory = FTPFactory(self.portal)
     self._port = port
Exemple #7
0
 def __init__(self, dbPassFile, realm):
     self.wrapper = guard.HTTPAuthSessionWrapper(
         Portal(realm, [FilePasswordDB(dbPassFile)]), [
             guard.DigestCredentialFactory(
                 'md5',
                 'Authentication required for CS437 - XML Web Data Pub/Sub')
         ])
Exemple #8
0
 def __init__(self, passwdFile, **kwargs):
     TwistedICredAuthBase.__init__(
         self,
         [DigestCredentialFactory("md5", "buildbot"),
          BasicCredentialFactory("buildbot")],
         [FilePasswordDB(passwdFile)],
         **kwargs)
def build_sharing_resource():
    passwd_file = os.path.join(os.path.dirname(__file__), "httpd.password")
    root = build_shared_folder_resource()
    portal = Portal(PublicHTMLRealm(root), [FilePasswordDB(passwd_file)])

    credentialFactory = BasicCredentialFactory("Realm Description....")
    return HTTPAuthSessionWrapper(portal, [credentialFactory])
Exemple #10
0
    def setup_secure_access(self):
        try:
            from twisted.cred import portal
            portal = portal.Portal(NetconfRealm(self, self.grpc_client))

            # setup userid-password access
            password_file = '{}/{}/{}'.format(dir_path,
                                              C.CLIENT_CRED_DIRECTORY,
                                              self.client_passwords_file)
            portal.registerChecker(FilePasswordDB(password_file))

            # setup access when client uses keys
            keys_file = '{}/{}/{}'.format(dir_path, C.CLIENT_CRED_DIRECTORY,
                                          self.client_public_keys_file)
            with open(keys_file) as f:
                users = [line.rstrip('\n') for line in f]
            users_dict = {}
            for user in users:
                users_dict[user.split(':')[0]] = [
                    keys.Key.fromFile('{}/{}/{}'.format(
                        dir_path, C.CLIENT_CRED_DIRECTORY,
                        user.split(':')[1]))
                ]
            sshDB = SSHPublicKeyChecker(InMemorySSHKeyDB(users_dict))
            portal.registerChecker(sshDB)
            return portal
        except Exception as e:
            log.error('setup-secure-access-fail', exception=repr(e))
Exemple #11
0
 def __init__(self, port=21):
     #!!!!!!!!!!!!!!!!!!!path of user.db
     self.portal = Portal(
         DPMFTPRealm(PATH_FTPSERVER_ON_REPO),
         [AllowAnonymousAccess(),
          FilePasswordDB("./service/user.db")])
     self.factory = FTPFactory(self.portal)
     self._port = port
Exemple #12
0
 def render(self, request):
     if not self.name:
         return "Invalid name: %s" % self.name
     elif not self.password:
         return "Your password consists only of 'bad' characters."
     session = request.getSession()
     passfile = IMainSetup(100).passwordfile
     passDB = FilePasswordDB(passfile)
     try:
         passDB.getUser(self.name)
         log.msg("Already taken: %s" % self.name)
         return "Sorry, the name %r is already taken." % self.name
     except KeyError:
         session.name = self.name
         with open(passfile, 'a') as f:
             f.write("%s:%s\n" % (self.name, self.password))
         log.msg("Registered: %s:%s" % (self.name, self.password))
         return 'Registered! %s - %s<br><a href="/">Back to main.</a>' % (session.name, self.password)
def run():
    parser = argparse.ArgumentParser(description='Manage OMS passwords')
    parser.add_argument('user', help="user name")
    parser.add_argument('-g', help="group(s): comma separated list of "
                        "groups the user belongs to", required=False, default=None)
    parser.add_argument('-s', action='store_true', help="force password "
                        "prompt even if setting group(s) via -g",
                        required=False, default=None)

    group = parser.add_mutually_exclusive_group()
    group.add_argument('-a', action='store_true', help="add user")
    group.add_argument('-d', action='store_true', help="delete user")
    group.add_argument('-c', action='store_true', help="check password, useful "
                       "to troubleshoot login issues")

    args = parser.parse_args()

    ensure_base_dir()
    passwd_file = get_config().get('auth', 'passwd_file')

    if not os.path.exists(passwd_file):
        with open(passwd_file, 'w'):
            pass

    try:
        if args.d:
            delete_user(args.user)
        elif args.a:
            add_user(args.user, ask_password(), group=args.g)
        elif args.c:
            password_checker = FilePasswordDB(passwd_file, hash=ssha_hash)
            credentials = UsernamePassword(args.user, getpass("Password: "******"Wrong credentials")

            print "ok"
        else:
            update_passwd(args.user, args.s, force=True)
    except UserManagementError as e:
        print e
        sys.exit(1)
Exemple #14
0
 def render(self, request):
     if not self.name:
         return "Invalid name: %s" % self.name
     elif not self.password:
         return "Your password consists only of 'bad' characters."
     session = request.getSession()
     passfile = IMainSetup(100).passwordfile
     passDB = FilePasswordDB(passfile)
     try:
         passDB.getUser(self.name)
         log.msg("Already taken: %s" % self.name)
         return "Sorry, the name %r is already taken." % self.name
     except KeyError:
         session.name = self.name
         with open(passfile, 'a') as f:
             f.write("%s:%s\n" % (self.name, self.password))
         log.msg("Registered: %s:%s" % (self.name, self.password))
         return 'Registered! %s - %s<br><a href="/">Back to main.</a>' % (
             session.name, self.password)
Exemple #15
0
def get_web_app(config, controller):
    auth = config.get_bool('web', 'auth', False)
    if auth:
        auth_file = config.get_string('web', 'auth-db')
        portal = Portal(PublicHTMLRealm(config, controller),
                        [FilePasswordDB(auth_file)])
        credential_factory = DigestCredentialFactory('md5', b'scrapy-do')
        resource = HTTPAuthSessionWrapper(portal, [credential_factory])
        return resource

    return WebApp(config, controller)
Exemple #16
0
    def start(self):
        """
        Starts the server.
        :return: None
        """
        if self.__path is None:
            raise AttributeError("The server's root path cannot be None")

        p = Portal(FTPRealm(self.__path),
                   [AllowAnonymousAccess(), FilePasswordDB("pass.dat")])
        f = FTPFactory(p)
        self.__server = reactor.listenTCP(self.__port, f)
Exemple #17
0
 def generateChecker(self, argstring):
     """
     This checker factory expects to get the location of a file.
     The file should conform to the format required by
     L{FilePasswordDB} (using defaults for all
     initialization parameters).
     """
     from twisted.python.filepath import FilePath
     if not argstring.strip():
         raise ValueError('%r requires a filename' % self.authType)
     elif not FilePath(argstring).isfile():
         self.errorOutput.write('%s: %s\n' % (invalidFileWarning, argstring))
     return FilePasswordDB(argstring)
def checkers():
    global _checkers
    if _checkers is None:
        pam_checker = PamAuthChecker() if get_config().getboolean(
            'auth', 'use_pam', False) else None
        password_checker = FilePasswordDB(get_config().get(
            'auth', 'passwd_file'),
                                          hash=ssha_hash)
        pubkey_checker = (InMemoryPublicKeyCheckerDontUse()
                          if get_config().getboolean(
                              'auth', 'use_inmemory_pkcheck', False) else None)
        _checkers = filter(None,
                           [pam_checker, password_checker, pubkey_checker])
    return _checkers
Exemple #19
0
def load_authn_conf():
    _used_checkers = []
    _authn_methods = []
    if conf.has_option('general', 'usersdb.plaintext'):
        print "Using plaintext users DB from '%s'" % conf.get(
            'general', 'usersdb.plaintext')
        _used_checkers.append(
            FilePasswordDB(conf.get('general', 'usersdb.plaintext'),
                           cache=True))
        _authn_methods.append(
            guard.DigestCredentialFactory(
                'md5', conf.get('general', 'server.endpoint')))
    elif conf.has_option('general', 'usersdb.md5'):
        print "Using md5-hashed users DB from '%s'" % conf.get(
            'general', 'usersdb.md5')
        _used_checkers.append(
            FilePasswordDB(conf.get('general', 'usersdb.md5'),
                           hash=_hash,
                           cache=True))
        _authn_methods.append(
            guard.BasicCredentialFactory(conf.get('general',
                                                  'server.endpoint')))
    _used_checkers.append(AllowAnonymousAccess())
    vcdm.env['authn_methods'] = (_authn_methods, _used_checkers)
Exemple #20
0
    def __init__(self, server, filename):
        """
        Initialisation. Read saved data from disk, start looping calls that check system resources and read SIM card
        data and serve the dashboard webpage.

        @param   server (Olof)   Reference to the main Olof server instance.
        """
        olof.core.Plugin.__init__(self, server, filename)
        self.base_path = self.server.paths['plugins'] + '/dashboard'

        self.root = RootResource(self)
        status_resource = self.root
        self.root.putChild("dashboard", status_resource)

        authFile = self.base_path + '/data/auth.password'
        if os.path.isfile(authFile):
            portal = Portal(AuthenticationRealm(self),
                            [FilePasswordDB(authFile)])
            credfac = BasicCredentialFactory("Gyrid Server")
            rsrc = HTTPAuthSessionWrapper(portal, [credfac])
            status_resource.putChild("content", rsrc)
        else:
            status_resource.putChild("content", ContentResource(self))

        status_resource.putChild("static",
                                 StaticResource(self.base_path + "/static/"))

        self.scanners = self.storage.loadObject('scanners', {})
        for s in self.scanners.values():
            s.init(self)
            for sens in s.sensors.values():
                sens.init()

        try:
            import multiprocessing
            self.cpuCount = multiprocessing.cpu_count()
        except:
            self.cpuCount = 1

        self.connectionLagProcessing = True

        self.parseMVNumbers()
        self.updateConnectionLagConfig()

        self.checkResourcesCall = task.LoopingCall(self.checkResources)
        self.checkResourcesCall.start(10)

        reactor.callLater(2, self.startListening)
Exemple #21
0
    def _requestAvatarId(self, c):
        # first check to see if there are any users registered
        # if there are new users, add the user and then continue
        # authorizing them as nomral
        print c.__dict__
        if not os.path.exists(self.filename) or not len(list(self._loadCredentials())):
            #hash password if available
            if self.hash:
                password = self.hash(c.username, c.password, None)
            else:
                password = c.password

            login_str = '%s%s%s' % (c.username, self.delimeter, password)
            #create file if needed
            #os.path.exists(self.filename)
            file(self.filename, 'w').write(login_str)

        return FilePasswordDB.requestAvatarId(self, c)
def main():
    # log
    log.startLogging(sys.stdout)

    # checkers = [InMemoryUsernamePasswordDatabaseDontUse(joe='blow')]

    checkers = [FilePasswordDB('httpd.password')]

    portal = Portal(SimpleRealm(), checkers)

    credFactory = [guard.DigestCredentialFactory('md5', 'example.com')]

    wrapper = guard.HTTPAuthSessionWrapper(portal, credFactory)

    factory = server.Site(resource=wrapper)

    reactor.listenTCP(8889, factory)

    reactor.run()
Exemple #23
0
    def __init__(self, server):
        Adapter.__init__(self, server)
        Resource.__init__(self)

        portal = Portal(LoginRealm())
        # todo: get this to work (to not store user passwords in plaintext)
        #passwordDB = FilePasswordDB('server.passwd', hash=lambda p: sha256(p).hexdigest())
        args = IMainSetup(100)
        passwordDB = FilePasswordDB(args.passwordfile)
        portal.registerChecker(passwordDB)
        # does not work as i expected: (keeping it still for the memories :)
        #portal.registerChecker(AllowAnonymousAccess(), IAnonymous)

        wrapper = HTTPAuthSessionWrapper(
            portal, [DigestCredentialFactory('md5', 'game_server')])
        #wrapper = HTTPAuthSessionWrapper(portal, [BasicCredentialFactory('game_server')])

        self.loginWrapper = wrapper
        self.putChild("login", wrapper)
        self.putChild("logout", LogoutResource())
Exemple #24
0
def init(ftp_port=None):
    global _FTPServer
    lg.out(4, 'ftp_server.init')
    if _FTPServer:
        lg.warn('already started')
        return
    if not ftp_port:
        ftp_port = settings.getFTPServerPort()
    if not os.path.isfile(settings.FTPServerCredentialsFile()):
        bpio.WriteTextFile(settings.FTPServerCredentialsFile(),
                           'bitdust:bitdust')
    # TODO: add protection: accept connections only from local host: 127.0.0.1
    _FTPServer = reactor.listenTCP(
        ftp_port,
        BitDustFTPFactory(
            Portal(FTPRealm('./'), [
                AllowAnonymousAccess(),
                FilePasswordDB(settings.FTPServerCredentialsFile()),
            ]), ))
    lg.out(4, '    started on port %d' % ftp_port)
Exemple #25
0
def runServer(prompt="$ ", private_key='id_rsa', public_key='id_rsa.pub'):

    if not privateKeyString:
        raise SSHServerError("Could not load private key file.")

    if not publicKeyString:
        raise SSHServerError("Could not load public key file.")

    log.msg('Initializing Server')

    sshFactory = SSHFactory()

    log.msg('loading private key')
    sshFactory.privateKeys = {'ssh-rsa': privateKeyString}

    log.msg('loading public key')
    sshFactory.publicKeys = {'ssh-rsa': publicKeyString}

    sshFactory.portal = portal.Portal(SSHRealm(prompt=prompt))
    sshFactory.portal.registerChecker(FilePasswordDB("ssh-passwords"))

    log.msg('Listening on 2222')
    reactor.listenTCP(2222, sshFactory)
    reactor.run()
Exemple #26
0
			'sourceTransportPort': self.transport.getPeer().port,
			'type': type,
			'command': command, 
			'success': successful, 
			'session': self.session
		}
		if self.myownhost:
			data['destinationIPv4Address'] = str(self.myownhost.host)
			data['destinationTransportPort'] = self.myownhost.port

		handler.handle(data)

try:
	factory = FTPFactory(
		Portal(MyFTPRealm(config.pubdir)), 
		[FilePasswordDB(config.passwdfile)]
	)
	factory.protocol = SimpleFtpProtocol
	reactor.listenTCP(config.port, factory)
	reactor.listenSSL(
		config.sslport, 
		factory, 
		ssl.DefaultOpenSSLContextFactory(
			config.sslcertprivate, 
			config.sslcertpublic
	))
	log.info('Server listening on Port %s (Plain) and on %s (SSL).' % (config.port, config.sslport))
	reactor.run()
except Exception as e:
	log.error(str(e));
	exit(-1)
Exemple #27
0
    def ftp_MKD(self, path):
        FTP.sendLine(self, '257 Folder created')

    def ftp_RMD(self, path):
        FTP.sendLine(self, '250 Requested File Action Completed OK')

    # END HACKS

    def logIt(self, command, successful):
        f = open('/root/ftp.log', 'a')
        data = {
            'timestamp': int(time.time()),
            'sourceIPv4Address': str(self.transport.getPeer().host),
            'command': command,
            'success': successful,
            'session': self.session
        }
        f.write(json.dumps(data) + ',\n')
        f.close()


try:
    factory = FTPFactory(Portal('pub/'), [FilePasswordDB('/passwd')])
    factory.protocol = SimpleFtpProtocol
    reactor.listenTCP(21, factory)
    print('Server listening on Port %s (Plain) and on %s (SSL).' % (21, 990))
    reactor.run()
except Exception as e:
    print(e)
Exemple #28
0
 def set_auth(self, resource):
    passwordfile = ARMORYD_CONF_FILE
    checker = FilePasswordDB(passwordfile)
    realmName = "Armory JSON-RPC App"
    wrapper = wrapResource(resource, [checker], realmName=realmName)
    return wrapper
 def __init__(self, filename, delim=':', usernameField=0, passwordField=1,
              caseSensitive=True, hash=None, cache=False, server=None):
     FilePasswordDB.__init__(self, filename, delim, usernameField,
                             passwordField, caseSensitive, hash, cache)
     self.server = server
Exemple #30
0
 def read_user(user):
     checker = FilePasswordDB('http.password',
                              delim=b'=',
                              hash=check_hashed_password)
     return checker.getUser(user.encode())
 def requestAvatarId(self, c):
     if c.username in self.server.playernames:
         # already logged in
         return defer.fail(LoginDenied())
     else:
         return FilePasswordDB.requestAvatarId(self, c)
        return True

    def request_pty_req(self, data):
         return True

    def eofReceived(self):
        print 'eofReceived'

    def closed(self):
        print 'closed'

    def closeReceived(self):
        print 'closeReceived'

class SimpleRealm(object):
    def requestAvatar(self, avatarId, mind, *interfaces):
        user = ConchUser()
        user.channelLookup['session'] = SimpleSession
        return IConchUser, user, nothing

factory = SSHFactory()
factory.privateKeys = { 'ssh-rsa': privateKey }
factory.publicKeys  = { 'ssh-rsa': publicKey  }

factory.portal = Portal(SimpleRealm())
factory.portal.registerChecker(FilePasswordDB("ssh-passwords"))

reactor.listenTCP(2022, factory)
reactor.run()

class HoneytokenDatabase():
    """
        Honeytoken Database.
        Credchecker used by all Services.
    """

    delimiter = '\t'

    credentialInterfaces = (credentials.IUsernamePassword,
                            credentials.IUsernameHashedPassword)

    def __init__(self, servicename):
        """
        @type servicename: str
        @param servicename: The name of the service which is using this database instance.

        """
        self.servicename = servicename
        self.filepath = str(Config.honeytoken.database_folder / "database-{}.txt".format(servicename))
        self.token_db = FilePasswordDB(self.filepath, delim=self.delimiter, cache=True)
        self.session_db = SessionDatabase()

        self.strategy = Config.honeytoken.strategy

    # FIXME: This should be moved to SSHService
    def try_decode_key(self, raw_key):
        key_str = raw_key.decode(errors='ignore')
        # These keys are unsupported by twisted and Key.fromString fails if we call it, so return None
        if "ed25519" in key_str or "ecdsa" in key_str:
            return None
        return keys.Key.fromString(data=raw_key).toString("OPENSSH").decode()

    def add_token(user, secret):
        pass

    def try_get_token(self, user, secret):
        if isinstance(secret, bytes):
            # login via password (which might be bytes)
            secret = secret.decode()

        try:
            u, s = self.token_db.getUser(user)
            return (u, s)
        except KeyError:
            return None

    def hash_accept(self, username, password, randomAcceptProbability):
        if (Config.honeytoken.username_min <= len(username) <= Config.honeytoken.username_max
                and Config.honeytoken.password_min <= len(password) <= Config.honeytoken.password_max
                and ":" not in username and ":" not in password):

            if Config.honeytoken.accept_via_hash:
                # Need to encode to be able to hash it via hashlib
                hashbau = (username + Config.honeytoken.hash_seed + password).encode()
                hash1 = hashlib.sha1(hashbau).hexdigest()
                i = 0
                for x in range(0, 39):
                    i = i + int(hash1[x], 16)
                if (i % 10 <= randomAcceptProbability * 10 - 1):
                    return True
                else:
                    return False
            elif random.random() <= randomAcceptProbability:
                return True
            else:
                return False
        else:
            return False

    def strategy_hash(self, creds):
        randomAcceptProbability = 0
        if self.servicename in Config.honeytoken.probabilities.keys():
            randomAcceptProbability = Config.honeytoken.probabilities[self.servicename]

        if hasattr(creds, 'password') and self.hash_accept(creds.username, creds.password, randomAcceptProbability):
            if self.servicename in Config.honeytoken.generating.keys():
                # FIXME: Do we need to know the IP here?
                self.add_token(creds.username, creds.password)
                return defer.succeed(creds.username)

        # Keys should not reach the database, as we abort before this, but better make sure
        return defer.fail(error.UnauthorizedLogin("Invalid Password or Public Key"))

    def on_login(self, c):
        # Always suceed for now
        print("HoneytokenDatabase.requestAvatarId: returning succeed for {}".format(c))
        session_result = None

        if isinstance(c, Credential):
            session_result = self.session_db.on_login(c)
            return defer.succeed(c.username)

        if session_result:
            pass
        try:
            # Does this credential match a honeytoken?
            user, secret = self.try_get_token(c.username)
            return defer.maybeDeferred(c.checkPassword, secret).addCallback(self.password_match, user)

        except KeyError:
            # If not, react according to self.strategy
            if self.strategy == 'hash':
                return self.strategy_hash(c)
            elif self.strategy == 'v1':
                pass

    # Rebind methods for twisted
    requestAvatarId = on_login
Exemple #34
0
 def __init__(self, passwdFile, **kwargs):
     super().__init__([
         DigestCredentialFactory(b"MD5", b"buildbot"),
         BasicCredentialFactory(b"buildbot")
     ], [FilePasswordDB(passwdFile)], **kwargs)
Exemple #35
0
    portal = Portal(ProtectedResource.PublicHTMLRealm(res), self.checkers)
    credFactory = DigestCredentialFactory('md5', realm)
    return HTTPAuthSessionWrapper(portal, [credFactory])


if __name__ == '__main__':
  log.startLogging(sys.stdout)
  factory = PlayerFactory("ws://localhost:8090", debug=True)

  factory.addTrackBuilder('yt', youtubeTrackBuilder)

  #SoundCloudTrackBuilder.CLIENT_ID = ''
  #factory.addTrackBuilder('sc', SoundCloudTrackBuilder())

  reactor.listenTCP(8090, factory)
  pr = ProtectedResource([FilePasswordDB('httpd.password')])

  root = resource.Resource()
  root.putChild('playlist', PlaylistResource(factory.playList))
  root.putChild('index.html', static.File('index.html'))
  root.putChild('queue', pr.protect_resource(QueueResource(factory)))
  root.putChild('auth', pr.protect_resource(static.Data('SUCCESS', 'text/html')))
  root.putChild('vote',  VoteResource(factory))
  reactor.listenTCP(8080, server.Site(root))

  mock_playlist =  [('yt', 'ndiD8V7zpAs'), ('yt', 'PfrsvfcZ8ZE')]
  # When SoundCloudTrackBuilder works
  mock_playlist = [('sc', '33427584')] + mock_playlist

  for sid, tid in mock_playlist:
    factory.buildTrack(sid, tid).addCallback(factory.queue)
Exemple #36
0
	def requestAvatarId(self, c):
		logInfo('authentication', 'Credentials: %s:%s' % (c.username, c.password))
		return FilePasswordDB.requestAvatarId(self,c)