def __init__(self, pcontext: ListenerContext):
super().__init__()
self.p_context = pcontext
self.driverManager = DriverManager(pcontext.console,
pcontext.shutdownEvent,
startService=False)
self.client = client('sqs')
self.totalMessageReceived = 0
self.proxyManager = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
self.lockClient = Lock()
self.lockDriver = Lock()
def __init__(self, pcontext: RegisterContext):
super().__init__()
self.p_context = pcontext
self.driverManager = DriverManager(pcontext.console,
pcontext.shutdownEvent,
startService=False)
self.client = client('sqs')
self.totalAccountCreated = 0
self.proxyRegisterManager = ProxyManager(proxyFile=PROXY_FILE_REGISTER)
self.proxyListenerManager = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
self.userManager = UserManager(self.p_context.console)
self.userAgentManager = UserAgentManager()
self.lockClient = Lock()
self.lockDriver = Lock()
self.lockAccountCount = Lock()
vnc = True
#Manage log
logDir = (os.path.dirname(__file__)
or '.') + '/temp/register/' + datetime.now().strftime(
"%m-%d-%Y-%H-%M-%S") + '/'
logfile = logDir + 'all.log'
os.makedirs(logDir, exist_ok=True)
screenshotDir = logDir + 'screenshot/'
os.makedirs(screenshotDir, exist_ok=True)
#Util
shutdownEvent = Event()
config = Config()
console = Console(ouput=not noOutput, logfile=logfile)
proxyRegisterManager = ProxyManager(proxyFile=PROXY_FILE_REGISTER)
proxyListenerManager = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
userManager = UserManager(console)
userAgentManager = UserAgentManager()
client = boto3.client('sqs')
systemStats = Stats()
processes = []
users = []
maxProcess = config.REGISTER_MAX_PROCESS
if maxProcess < 0:
maxProcess = psutil.cpu_count(logical=True)
#Process communication
runnerStats = Array('i', 4)
processStates = Array('i', maxProcess)
class Register(Process):
def __init__(self, pcontext: RegisterContext):
super().__init__()
self.p_context = pcontext
self.driverManager = DriverManager(pcontext.console,
pcontext.shutdownEvent,
startService=False)
self.client = client('sqs')
self.totalAccountCreated = 0
self.proxyRegisterManager = ProxyManager(proxyFile=PROXY_FILE_REGISTER)
self.proxyListenerManager = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
self.userManager = UserManager(self.p_context.console)
self.userAgentManager = UserAgentManager()
self.lockClient = Lock()
self.lockDriver = Lock()
self.lockAccountCount = Lock()
def run(self):
self.p_context.console.log('Start process %d' % current_process().pid)
threads = []
messages = []
for x in range(self.p_context.accountToCreate):
messages.append({
'Body':
dumps({
'user':
self.userManager.createRandomUser(
proxy=self.proxyListenerManager.getRandomProxy(),
userAgent=self.userAgentManager.getRandomUserAgent(),
application='spotify',
),
'playlist':
self.p_context.playlist
})
})
while True:
try:
sleep(self.p_context.config.REGISTER_SPAWN_INTERVAL)
freeSlot = self.p_context.maxThread - len(threads)
if freeSlot and len(messages) and (
not self.p_context.shutdownEvent.is_set()):
message = messages.pop()
body = loads(message['Body'])
t_context = TaskContext(
batchId=self.p_context.batchId,
playlist=body['playlist'],
proxy=self.proxyRegisterManager.getRandomProxy(),
user=body['user'],
headless=self.p_context.headless,
vnc=self.p_context.vnc)
t = Thread(target=self.runner, args=(t_context, ))
t.start()
threads.append(t)
leftThread = []
for thread in threads:
if thread.is_alive():
leftThread.append(thread)
else:
del thread
collect()
pass
threads = leftThread
self.p_context.threadsCount[self.p_context.channel] = len(
threads)
if len(threads) == 0 and len(messages) == 0:
break
except:
self.p_context.console.exception(
'Register process #%d exception' % self.p_context.channel)
self.driverManager.purge()
self.p_context.console.log('Stop process %d' % current_process().pid)
del self.driverManager
del self.p_context
del self.userAgentManager
del self.userManager
del self.proxyListenerManager
del self.proxyRegisterManager
collect()
def runner(self, t_context: TaskContext):
tid = current_thread().native_id
self.p_context.console.log('Start thread %d' % tid)
driver = None
vdisplay = None
x11vnc = None
userDataDir = None
spotify = None
try:
if self.p_context.shutdownEvent.is_set():
return
if t_context.headless == False:
vdisplay = Xvfb(width=1280,
height=1024,
colordepth=24,
tempdir=None,
noreset='+render')
vdisplay.start()
if t_context.vnc:
x11vnc = X11vnc(vdisplay)
x11vnc.start()
with self.lockDriver:
driverData = self.driverManager.getDriver(
type='chrome',
uid=tid,
user=t_context.user,
proxy=t_context.proxy,
headless=t_context.headless)
if not driverData:
raise Exception('No driverData was returned from adapter')
driver = driverData['driver']
userDataDir = driverData['userDataDir']
if not driver:
raise Exception('No driver was returned from adapter')
except:
self.p_context.console.error('Unavailale webdriver: %s' %
format_exc())
else:
try:
spotify = Spotify.Adapter(driver, self.p_context.console,
self.p_context.shutdownEvent,
t_context.batchId)
self.p_context.console.log('#%d Start create account for %s' %
(tid, t_context.user['email']))
if spotify.register(t_context.user):
self.p_context.console.log('#%d Account created for %s' %
(tid, t_context.user['email']))
message = {
'user': t_context.user,
'playlist': t_context.playlist
}
with self.lockClient:
try:
self.client.send_message(
QueueUrl=self.p_context.config.SQS_ENDPOINT,
MessageBody=dumps(message),
DelaySeconds=1,
)
except:
self.p_context.console.exception(
'T#%d Failed to send message to the queue %s' %
(tid, self.p_context.config.SQS_ENDPOINT))
else:
self.p_context.console.log(
'#%d Message sent for %s' %
(tid, t_context.user['email']))
with self.lockAccountCount:
self.totalAccountCreated += 1
self.p_context.accountsCount[
self.p_context.
channel] = self.totalAccountCreated
else:
if not self.p_context.shutdownEvent.is_set():
self.p_context.console.error(
'#%d Failed to create account for %s' %
(tid, t_context.user['email']))
except:
self.p_context.console.exception()
if driver:
try:
driver.quit()
del driver
except:
pass
if spotify:
try:
del spotify
except:
pass
if userDataDir:
try:
rmtree(path=userDataDir, ignore_errors=True)
except:
pass
if x11vnc: #Terminate vnc server if any
try:
x11vnc.stop()
del x11vnc
except:
pass
if vdisplay:
try:
vdisplay.stop()
del vdisplay
except:
pass
self.p_context.console.log('Stop thread %d' % tid)
collect()
if arg == '--vnc':
vnc = True
logDir = (os.path.dirname(__file__)
or '.') + '/temp/listener/' + datetime.now().strftime(
"%m-%d-%Y-%H-%M-%S") + '/'
logfile = 'all.log'
os.makedirs(logDir, exist_ok=True)
screenshotDir = logDir + 'screenshot/'
os.makedirs(screenshotDir, exist_ok=True)
shutdownEvent = Event()
config = Config()
processes = []
console = Console(ouput=not noOutput, logfile=logfile)
proxyManager = ProxyManager(PROXY_FILE_LISTENER)
systemStats = Stats()
maxProcess = config.LISTENER_MAX_PROCESS
if maxProcess < 0:
maxProcess = psutil.cpu_count(logical=True)
runnerStats = Array('i', 4)
runnerStats[STAT_PLAYED] = 0
runnerStats[STAT_LOGGED_IN] = 0
runnerStats[STAT_ERROR] = 0
runnerStats[STAT_DRIVER_NONE] = 0
processStates = Array('i', maxProcess)
messages = []
class Listener(Process):
def __init__(self, pcontext: ListenerContext):
super().__init__()
self.p_context = pcontext
self.driverManager = DriverManager(pcontext.console,
pcontext.shutdownEvent,
startService=False)
self.client = client('sqs')
self.totalMessageReceived = 0
self.proxyManager = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
self.lockClient = Lock()
self.lockDriver = Lock()
def run(self):
threads = []
messages = []
while True:
try:
sleep(self.p_context.config.LISTENER_SPAWN_INTERVAL)
freeSlot = self.p_context.maxThread - len(threads)
if len(messages) < 1 and freeSlot and (
not self.p_context.shutdownEvent.is_set()):
try:
with self.lockClient:
response = self.client.receive_message(
QueueUrl=self.p_context.config.SQS_ENDPOINT,
MaxNumberOfMessages=freeSlot,
VisibilityTimeout=600,
WaitTimeSeconds=2,
)
if 'Messages' in response:
newMessages = response['Messages']
messages = newMessages + messages
self.totalMessageReceived += len(newMessages)
self.p_context.messagesCount[
self.p_context.
channel] = self.totalMessageReceived
except:
self.p_context.console.exception()
if freeSlot and len(messages):
message = messages.pop()
body = loads(message['Body'])
proxy = None
if self.p_context.config.LISTENER_OVERIDE_PLAYLIST:
body[
'playlist'] = self.p_context.config.LISTENER_OVERIDE_PLAYLIST
if self.p_context.config.LISTENER_OVERIDE_PROXY:
proxy = self.proxyManager.getRandomProxy()
t_context = TaskContext(
batchId=self.p_context.batchId,
playlist=body['playlist'],
proxy=proxy,
user=body['user'],
receiptHandle=message['ReceiptHandle'],
vnc=self.p_context.vnc,
headless=self.p_context.headless)
t = Thread(target=self.runner, args=(t_context, ))
t.start()
threads.append(t)
leftThread = []
for thread in threads:
if thread.is_alive():
leftThread.append(thread)
else:
del thread
collect()
threads = leftThread
self.p_context.threadsCount[self.p_context.channel] = len(
threads)
if len(threads) == 0:
break
except:
self.p_context.console.exception()
del self.driverManager
del self.p_context
collect()
def runner(self, t_context: TaskContext):
tid = current_thread().native_id
self.p_context.console.log('#%d Start' % tid)
driver = None
try:
if self.p_context.shutdownEvent.is_set():
return
vdisplay = None
x11vnc = None
if t_context.headless == False:
width = 1280
height = 1024
if 'windowSize' in t_context.user:
[width, height] = t_context.user['windowSize'].split(',')
vdisplay = Xvfb(width=width,
height=height,
colordepth=24,
tempdir=None,
noreset='+render')
vdisplay.start()
if t_context.vnc:
x11vnc = X11vnc(vdisplay)
x11vnc.start()
with self.lockDriver:
driverData = self.driverManager.getDriver(
type='chrome',
uid=tid,
user=t_context.user,
proxy=t_context.proxy,
headless=t_context.headless)
if not driverData:
return
driver = driverData['driver']
userDataDir = driverData['userDataDir']
if not driver:
return
except:
self.p_context.console.error('Unavailale webdriver: %s' %
format_exc())
else:
try:
spotify = Spotify.Adapter(driver, self.p_context.console,
self.p_context.shutdownEvent)
if spotify.login(t_context.user['email'],
t_context.user['password']):
self.p_context.console.log('#%d Logged In' % tid)
if not self.p_context.shutdownEvent.is_set():
self.p_context.console.log('#%d Start listening...' %
tid)
spotify.playPlaylist(t_context.playlist,
self.p_context.shutdownEvent, 90,
110)
self.p_context.console.log('#%d Played' % tid)
with self.lockClient:
self.client.delete_message(
QueueUrl=self.p_context.config.SQS_ENDPOINT,
ReceiptHandle=t_context.receiptHandle)
self.p_context.console.log('#%d Message deleted' % tid)
except:
self.p_context.console.exception()
spotify.saveScreenshot()
if driver:
try:
driver.quit()
del driver
except:
pass
if userDataDir:
try:
rmtree(path=userDataDir, ignore_errors=True)
except:
pass
if x11vnc: #Terminate vnc server if any
try:
x11vnc.stop()
del x11vnc
except:
pass
if vdisplay:
try:
vdisplay.stop()
del vdisplay
except:
pass
collect()
pass
driverManager.purge()
if __name__ == '__main__':
startTime = time()
config = Config()
processes = []
console = Console()
driverManager = DriverManager(console)
driverVersion = driverManager.getDriverVersion('chrome')
browserVersion = driverManager.getBrowserVersion('chrome')
client = boto3.client('sqs')
userManager = UserManager(console)
userAgentManager = UserAgentManager()
proxyManagerListener = ProxyManager(proxyFile=PROXY_FILE_LISTENER)
proxyManagerRegister = ProxyManager(proxyFile=PROXY_FILE_REGISTER)
lock = Lock()
stats = Stats()
users = []
#Start proxy server
proxy.start([],
plugins=[
ProxyRedirect(
'rapempireinc2020',
'gktgfks36flx',
proxyManager=ProxyManager(PROXY_FILE_LISTENER))
])