class LuminateOnlineClient(LuminatOnline.Client):
def __init__(self):
self.transport = THttpClient('localhost', 9090, '/luminate.binary')
self.transport.open()
LuminatOnline.Client.__init__(self, TBinaryProtocol.TBinaryProtocol(self.transport))
def close(self):
self.transport.close()
def _connect(self):
if self.path is None:
self._socket = TSocket(self.host, self.port)
else:
self._socket = THttpClient(self._makeConnectURI())
self._socket.setTimeout(int(self.connect_timeout * 1000))
self._transport = self.transport_class(self._socket)
self._protocol = self.protocol_class(self._transport)
self._client = self.module.Client(self._protocol)
self._transport.open()
def add_http_mode_support(username=user,
password=password,
port=port,
httpPath="/cliservice",
host=hostname,
transportMode="http"):
ap = "%s:%s" % (username, password)
_transport = THttpClient(host, port=port, path=httpPath)
_transport.setCustomHeaders(
{"Authorization": "Basic " + base64.b64encode(ap).strip()})
return _transport
def wraps(*args, **kwargs):
user_store_http_client = THttpClient(settings.EVERNOTE_STORE_URI)
user_store_protocol = TBinaryProtocol(user_store_http_client)
user_store = UserStore.Client(user_store_protocol)
note_store_url = user_store.getNoteStoreUrl(
settings.EVERNOTE_DEVELOPER_TOKEN)
note_store_http_client = THttpClient(note_store_url)
note_store_protocol = TBinaryProtocol(note_store_http_client)
note_store = NoteStore.Client(note_store_protocol)
kwargs['user_store'] = user_store
kwargs['note_store'] = note_store
return func(*args, **kwargs)
def createService(self, path, serviceFunc, headers=None):
transport = THttpClient(f"https://gd2.line.naver.jp{path}")
if headers is None:
headers = {
"X-Line-Application": self.account.getLineApplication(),
"User-Agent": self.account.getUserAgent(),
"X-Line-Access": self.account.getAuthToken(),
}
# setting the headers for the transport
transport.setCustomHeaders(headers)
# initiating the factory for CompactProtocol
factory = TCompactProtocolFactory()
# getting the CompactProtocol
protocol = factory.getProtocol(transport)
# initiating a new client using the protocol provided
return serviceFunc.Client(protocol)
def _connect(self):
if self.path is None:
self._socket = TSocket(self.host, self.port)
else:
self._socket = THttpClient(self._makeConnectURI())
self._socket.setTimeout(int(self.connect_timeout * 1000))
self._transport = self.transport_class(self._socket)
self._protocol = self.protocol_class(self._transport)
if self.multiplex_service is not None:
self._protocol = TMultiplexedProtocol(
self._protocol,
self.multiplex_service,
)
self._client = self.module.Client(self._protocol)
self._transport.open()
def run():
# Setup Connection
transport = THttpClient("http://localhost:8080/thrift/hawk/json")
protocol = TJSONProtocol.TJSONProtocol(transport)
client = Hawk.Client(protocol)
# Make API Call
result = client.listBackends()
for backend in result:
print(backend)
def create(cls, host, port=DEFAULT_AURORA_PORT, encoding="json"):
"""
Parses a host name and sets up Torando and Thrift client
"""
# To recieve and send binary thrift to the Aurora master we need to set
# headers appropriately.
transport = THttpClient("http://%s:%s/api" % (host, str(port)))
# Set aurora credentials in transport header if the environment
# variables have been set
if os.getenv("AURORA_USERNAME") and os.getenv("AURORA_PASSWORD"):
username = os.getenv("AURORA_USERNAME")
password = os.getenv("AURORA_PASSWORD")
credentials = base64.encodestring(
"%s:%s" % (username, password)
).replace("\n", "")
auth_header = "Basic %s" % credentials
transport.setCustomHeaders({"Authorization": auth_header})
if encoding == "binary":
transport.setCustomHeaders(
{
"Content-Type": "application/vnd.apache.thrift.binary",
"Accept": "application/vnd.apache.thrift.binary",
}
)
protocol = TBinaryProtocol(transport)
elif encoding == "json":
protocol = TJSONProtocol(transport)
else:
raise Exception("Unknown encoding %s" % encoding)
client = Client(protocol)
return client
def get_http_transport(host, port, http_path, timeout=None, use_ssl=False,
ca_cert=None, auth_mechanism='NOSASL', user=None,
password=None):
# TODO: support timeout
if timeout is not None:
log.error('get_http_transport does not support a timeout')
if use_ssl:
url = 'https://%s:%s/%s' % (host, port, http_path)
log.debug('get_http_transport url=%s', url)
# TODO(#362): Add server authentication with thrift 0.12.
transport = THttpClient(url)
else:
url = 'http://%s:%s/%s' % (host, port, http_path)
log.debug('get_http_transport url=%s', url)
transport = THttpClient(url)
# Set defaults for PLAIN SASL / LDAP connections.
if auth_mechanism in ['PLAIN', 'LDAP']:
if user is None:
user = getpass.getuser()
log.debug('get_http_transport: user=%s', user)
if password is None:
if auth_mechanism == 'LDAP':
password = ''
else:
# PLAIN always requires a password for HS2.
password = '******'
log.debug('get_http_transport: password=%s', password)
auth_mechanism = 'PLAIN' # sasl doesn't know mechanism LDAP
# Set the BASIC auth header
auth = base64.encodestring('%s:%s' % (user, password)).strip('\n')
transport.setCustomHeaders({'Authorization': 'Basic %s' % auth})
return transport
def create(
cls, host, port=DEFAULT_AURORA_PORT, encoding='json'):
"""
Parses a host name and sets up Torando and Thrift client
"""
# To recieve and send binary thrift to the Aurora master we need to set
# headers appropriately.
transport = THttpClient('http://%s:%s/api' % (host, str(port)))
# Set aurora credentials in transport header if the environment
# variables have been set
if os.getenv('AURORA_USERNAME') and os.getenv('AURORA_PASSWORD'):
username = os.getenv('AURORA_USERNAME')
password = os.getenv('AURORA_PASSWORD')
credentials = base64.encodestring(
'%s:%s' % (username, password)).replace('\n', '')
auth_header = "Basic %s" % credentials
transport.setCustomHeaders({'Authorization': auth_header})
if encoding == 'binary':
transport.setCustomHeaders({
'Content-Type': 'application/vnd.apache.thrift.binary',
'Accept': 'application/vnd.apache.thrift.binary',
})
protocol = TBinaryProtocol(transport)
elif encoding == 'json':
protocol = TJSONProtocol(transport)
else:
raise Exception('Unknown encoding %s' % encoding)
client = Client(protocol)
return client
def _rebuild_protocol(self):
"""
Rebuild the transport, protocol from the configuration.
Should not be used directly by users.
Returns:
None
"""
if self.use_http:
# if use http transport,
prefix = 'https://' if self.use_ssl else 'http://'
self.transport = THttpClient(uri_or_host=prefix + self.host + ':' +
str(self.port))
self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
return
if self.use_ssl:
from thrift.transport.TSSLSocket import TSSLSocket
socket = TSSLSocket(host=self.host,
port=self.port,
validate=False,
socket_keepalive=self.keep_alive)
else:
socket = TSocket(host=self.host,
port=self.port,
socket_keepalive=self.keep_alive)
if self.authentication:
socket = TSaslClientTransport(
socket,
host=self.host,
service=self.authentication.service,
mechanism=self.authentication.mechanism,
username=self.authentication.username,
password=self.authentication.password,
)
self.transport = self._transport_type(socket)
self.protocol = self._protocol_type(self.transport)
def openTransport(self, endPoint, pool=False):
if pool:
#transport = THttpClientPool(self.lineServer + endPoint)
transport = THttpClient(self.lineServer + endPoint)
else:
transport = THttpClient(self.lineServer + endPoint)
transport.setCustomHeaders(self.thisHeaders)
protocol = TCompactProtocol(transport)
return BEService.Client(protocol)
def __init__(self, request):
BaseResponse.__init__(self)
self.params = request.values
self.username = self.params.get('user')
self.domain = self.params.get('server')
self.password = self.params.get('pass')
if isinstance(request.remote_addr, str):
self.ip = request.remote_addr
else:
self.ip = '127.0.0.1'
# self.transport = TSocket.TSocket('localhost', 8080)
# self.transport = THttpClient('http://localhost:8080/apiserver.php')
self.transport = THttpClient('http://localhost/dzapi/apiserver.php')
self.transport = TTransport.TBufferedTransport(self.transport)
self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
self.client = DzApi.Client(self.protocol)
self.transport.open()
def getMid(my_token):
headers= {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36",
"X-Line-Application": "CHROMEOS\t2.3.2\tChrome OS\t1",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
}
headers["X-Line-Access"] = my_token
transport = THttpClient("https://ga2.line.naver.jp" + '/api/v4/TalkService.do')
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
talk = BoteaterService.Client(protocol)
mid = talk.getProfile().mid
transport.close()
return mid
class IMApiClient(BaseResponse):
def __init__(self, request):
BaseResponse.__init__(self)
self.params = request.values
self.username = self.params.get('user')
self.domain = self.params.get('server')
self.password = self.params.get('pass')
if isinstance(request.remote_addr, str):
self.ip = request.remote_addr
else:
self.ip = '127.0.0.1'
# self.transport = TSocket.TSocket('localhost', 8080)
# self.transport = THttpClient('http://localhost:8080/apiserver.php')
self.transport = THttpClient('http://localhost/dzapi/apiserver.php')
self.transport = TTransport.TBufferedTransport(self.transport)
self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
self.client = DzApi.Client(self.protocol)
self.transport.open()
def user_exists(self):
if self.client.user_exists(self.username):
return self.reTrue
else:
return self.reNotExist
def user_avatar(self):
avatar = self.client.user_avatar(self.params.get('uid'), self.params.get('size'))
return avatar
def user_login(self):
if self.client.user_exists(self.username):
uid = self.client.user_login(self.ip, self.username, self.password, self.params.get('questionid'), self.params.get('answer'), self.params.get('fastloginfield'),)
if uid > 0:
# self.uid = uid
return self.reSuccess
else:
return self.reInvalidPass
else:
return self.reError
def set_password(self):
if any(self.password):
if True:
return self.reSuccess
else:
return self.reError
def remove_user(self):
if self.user_exists()[1] == 'true':
if True:
return self.reSuccess
else:
return self.reNotAllow
else:
return self.reNotExist
def remove_user_validate(self):
if self.user_exists()[1] == 'true':
if self.user_login()[1] == 'success' and True:
return self.reSuccess
else:
return self.reInvalidPass
else:
return self.reNotExist
def get_user(self):
if self.user_exists()[1] == 'true':
return [200, str(self.client.get_user(self.params.get('uid')))]
else:
return self.reError
def get_userfield(self):
if self.user_exists()[1] == 'true':
return [200, str(self.client.get_userfield(self.params.get('uid')))]
else:
return self.reError
def user_register(self):
if self.user_exists()[1] != 'true':
result = self.client.user_register(self.ip, self.username, self.params.get('password'), self.params.get('password2'), self.params.get('email'), self.params.get('questionid'), self.params.get('answer'))
return [200, str(result)]
else:
return self.reExistUser
def get_threadslist(self):
threadslist = self.client.get_threadslist(self.params.get('fid'), self.params.get('page'), self.params.get('filter'))
for thread in threadslist:
thread['subject'] = thread['subject'].decode('utf-8')
return [200, str(threadslist)]
def get_postslist(self):
postslist = self.client.get_postslist(self.params.get('tid'), self.params.get('page'), self.params.get('ordertype'))
for post in postslist:
post['message'] = post['message'].decode('utf-8')
return [200, str(postslist)]
def __init__(self, my_app, my_token=None):
self.lineServer = "https://ga2.line.naver.jp"
self.lineOBS = "https://obs-sg.line-apps.com"
self.boteaterApi = "https://api.boteater.us"
self.liffServer = "https://api.line.me/message/v3/share"
self.stickerLink = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.stickerLinkAnimation = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.dataHeaders = {
"android_lite": {
"User-Agent": "LLA/2.11.1 samsung 5.1.1",
"X-Line-Application": "ANDROIDLITE\t2.11.1\tAndroid OS\t5.1.1",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"android": {
"User-Agent": "Line/10.1.1",
"X-Line-Application": "ANDROID\t10.1.1\tAndroid OS\t5.1.1",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"ios_ipad": {
"User-Agent": "Line/10.1.1",
"X-Line-Application": "IOSIPAD\t10.1.1\tiPhone 8\t11.2.5",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"ios": {
"User-Agent": "Line/10.1.1",
"X-Line-Application": "IOS\t10.1.1\tiPhone 8\t11.2.5",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"chrome": {
"User-Agent":
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36",
"X-Line-Application": "CHROMEOS\t2.3.2\tChrome OS\t1",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"desktopwin": {
"User-Agent": "Line/5.12.3",
"X-Line-Application": "DESKTOPWIN\t5.21.3\tWindows\t10",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
},
"desktopmac": {
"User-Agent": "Line/5.12.3",
"X-Line-Application": "DESKTOPMAC\t5.21.3\tMAC\t10.15",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
}
}
if my_app in self.dataHeaders:
self.headers = self.dataHeaders[my_app]
if my_token != None:
self.headers["X-Line-Access"] = my_token
else:
self.headers["X-Line-Access"] = self.qrLogin(self.headers)
else:
raise Exception('APP not found!!!')
### CONNECT TO POOL ###
transport = THttpClient(self.lineServer + '/P4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.pool = OperationService.Client(protocol)
### CONNECT TO TALK ###
transport = THttpClient(self.lineServer + '/api/v4/TalkService.do')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.talk = TalkService.Client(protocol)
### CONNECT TO CHANNEL ###
transport = THttpClient(self.lineServer + '/CH4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.channel = ChannelService.Client(protocol)
### CONNECT TO CALL ###
transport = THttpClient(self.lineServer + '/V4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.call = CallService.Client(protocol)
### CONNECT TO SHOP ###
transport = THttpClient(self.lineServer + '/TSHOP4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.shop = ShopService.Client(protocol)
### CONNECT TO LIFF ###
transport = THttpClient(self.lineServer + '/LIFF1')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.liff = LiffService.Client(protocol)
self.profile = self.getProfile()
self.lastOP = self.getLastOpRevision()
self.liffPermision()
self.tokenOBS = self.acquireEncryptedAccessToken()
print("[ Login ] Display Name: " + self.profile.displayName)
print("[ Login ] Auth Token: " + self.headers["X-Line-Access"])
### TIMELINE HEADERS ###
self.tl_headers = copy.deepcopy(self.headers)
self.tl_headers["X-Line-ChannelToken"] = self.issueChannelToken(
'1341209950').channelAccessToken
self.tl_headers["X-Line-Mid"] = self.profile.mid
self.tl_headers["X-Line-AcceptLanguage"] = 'en'
self.tl_headers[
"X-Requested-With"] = 'jp.naver.line.android.LineApplication'
self.tl_headers["Content-Type"] = 'application/json'
def qrLogin(self, headers):
sys_name = "BE-Team"
transport = THttpClient(self.lineServer + '/api/v4/TalkService.do')
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
talk = TalkService.Client(protocol)
qr_code = talk.getAuthQrcode(keepLoggedIn=True,
systemName=sys_name,
returnCallbackUrl=True)
transport.close()
print(qr_code.callbackUrl)
headers["X-Line-Access"] = qr_code.verifier
transport = THttpClient(self.lineServer + '/api/v4p/rs')
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
auth = TalkService.Client(protocol)
get_access = json.loads(
requests.get(self.lineServer + '/Q', headers=headers).text)
login_request = LoginRequest()
login_request.type = 1
login_request.identityProvider = 1
login_request.keepLoggedIn = True
login_request.systemName = sys_name
login_request.verifier = get_access['result']['verifier']
result = auth.loginZ(login_request)
transport.close()
return result.authToken
def __init__(self, my_app, my_token=None, server=None):
if server == "japan":
self.line_server = "https://ga2.line.naver.jp" #Japan
elif server == "sg":
self.line_server = "https://ga2s.line.naver.jp" #Indo/Singapure
else:
self.line_server = "https://gd2.line.naver.jp" #Japan
self.line_obs = "https://obs-sg.line-apps.com"
self.boteater_api = "https://api.boteater.us"
self.liff_url = "https://api.line.me/message/v3/share"
self.sticker_link = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.sticker_link_animation = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.data_headers = self.read_json("headers.json")
if my_app in self.data_headers:
self.headers = self.data_headers[my_app]
if my_token != None:
self.headers["X-Line-Access"] = my_token
else:
del self.headers["X-Line-Access"]
self.headers["X-Line-Access"] = self.qr_login(self.headers)
else:
raise Exception('APP not found!!!')
### CONNECT TO POOL ###
transport = THttpClient(self.line_server + '/P4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.pool = BoteaterService.Client(protocol)
### CONNECT TO TALK ###
transport = THttpClient(self.line_server + '/api/v4/TalkService.do')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.talk = BoteaterService.Client(protocol)
### CONNECT TO CHANNEL ###
transport = THttpClient(self.line_server + '/CH4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.channel = BoteaterService.Client(protocol)
### CONNECT TO CALL ###
transport = THttpClient(self.line_server + '/V4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.call = BoteaterService.Client(protocol)
### CONNECT TO SHOP ###
transport = THttpClient(self.line_server + '/TSHOP4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.shop = BoteaterService.Client(protocol)
### CONNECT TO LIFF ###
transport = THttpClient(self.line_server + '/LIFF1')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.liff = BoteaterService.Client(protocol)
self.profile_data = self.talk.getProfile()
self.my_mid = self.profile_data.mid
self.last_op = self.pool.getLastOpRevision()
self.issue_liff_view()
self.tl_channel = self.issue_channel_token(
'1341209950').channelAccessToken
self.tl_headers = copy.deepcopy(self.headers)
self.tl_headers["X-Line-ChannelToken"] = self.tl_channel
self.tl_headers["X-Line-Mid"] = self.my_mid
self.tl_headers["X-Line-AcceptLanguage"] = 'en'
self.tl_headers[
"X-Requested-With"] = 'jp.naver.line.android.LineApplication'
self.tl_headers["Content-Type"] = 'application/json'
self.my_OBStoken = self.gen_obs_token()
print("[ Login ] Display Name: " + self.profile_data.displayName)
self.temp_data = self.read_json("tmp.json")
class ThriftClient(object):
"""Base Class for easy interfacing with thrift services.
`ThriftClient` can be used directly, or subclassed. If subclassed,
you can override a variety of attributes in order to make instantiation
more natural:
MODULE - The generated thrift module. Should include Iface and Client
HOST - A default host to connect to. Possibly a vip.
PORT - A default port to connect to.
PATH - An http path to request. Enables HTTP client mode.
TRANSPORT_CLASS - By default, `TFramedTransport` for socket servers,
`TBufferedTransport` for HTTP servers.
PROTOCOL_CLASS - By default, `TBinaryProtocol`
CONNECT_TIMEOUT - By default, 3.0 seconds
Instantiation should be done via the class methods, `for_hostport()`, and
`for_localhost()` as appropriate. These helpers more aggressively require
`port` and `host` arguments as appropriate. Generic construction arguments
override the class attribute defaults:
`module` - Generated thrift module.
`host` - IP address to connect to.
`port` - Port to connect to.
`path` - HTTP URI path to request. Enables HTTP client mode.
`connect_timeout` - Socket connection timeout
`transport_class` - Thrift transport class
`protocol_class` - Thrift protocol class
`multiplex_service` - Query `multiplex_service`-specific service name.
Additional features are configurable with other arguments:
`lazy` - Default: True, connect on first RPC invocation, instead of
at construction time.
Connections are made lazily, when the first rpc invocation occurs, so you
do need to wrap client instantiation with a try-catch.
"""
MODULE = None
HOST = None
PORT = None
PATH = None
TRANSPORT_CLASS = None
PROTOCOL_CLASS = TBinaryProtocol
CONNECT_TIMEOUT = 3.0
MULTIPLEX_SERVICE = None
@classmethod
def for_hostport(cls, host=None, port=None, **kwargs):
assert host or cls.HOST, "You must define a host!"
assert port or cls.PORT, "You must define a port!"
return cls(host=host, port=port, **kwargs)
@classmethod
def for_localhost(cls, port=None, **kwargs):
assert port or cls.PORT, "You must define a port!"
return cls(host='127.0.0.1', port=port, **kwargs)
def _initAttribute(self, name, value, *defaults):
defaults = list(defaults)
while value is None and len(defaults):
value = defaults.pop(0)
setattr(self, name, value)
def __init__(self,
host=None,
port=None,
module=None,
lazy=True,
connect_timeout=None,
transport_class=None,
protocol_class=None,
path=None,
multiplex_service=None):
self._initAttribute('host', host, self.HOST)
self._initAttribute('port', port, self.PORT)
self._initAttribute('path', path, self.PATH)
self._initAttribute('module', module, self.MODULE)
self._initAttribute('connect_timeout', connect_timeout,
self.CONNECT_TIMEOUT)
self._initAttribute('multiplex_service', multiplex_service,
self.MULTIPLEX_SERVICE)
# For non-http, default should be TFramed, for http, default TBuffered
if self.path is None:
fallback_transport = TFramedTransport
else:
fallback_transport = TBufferedTransport
self._initAttribute('transport_class', transport_class,
self.TRANSPORT_CLASS, fallback_transport)
self._initAttribute('protocol_class', protocol_class,
self.PROTOCOL_CLASS)
self.lazy = lazy
assert self.module is not None, "You must define a thrift module!"
# TODO: if self.module does not have a Client, but there is only one
# service moudule inside it, use that instead.
assert hasattr(self.module, 'Client'), \
"Module %s requires 'Client' class." % (self.module)
if self.lazy:
self._client = None
else:
self._connect()
def _connect(self):
if self.path is None:
self._socket = TSocket(self.host, self.port)
else:
self._socket = THttpClient(self._makeConnectURI())
self._socket.setTimeout(int(self.connect_timeout * 1000))
self._transport = self.transport_class(self._socket)
self._protocol = self.protocol_class(self._transport)
if self.multiplex_service is not None:
self._protocol = TMultiplexedProtocol(
self._protocol,
self.multiplex_service,
)
self._client = self.module.Client(self._protocol)
self._transport.open()
def _makeConnectURI(self):
assert self.path.startswith('/')
host = self.host
# If host is a v6 addr, we need to format the URI a little bit
# differently in order to parse its port out according to spec
if ':' in host:
assert sys.version >= '2.7', \
"Native v6 IP URLs not parseable on Python < 2.7"
host = '[{host}]'.format(host=host)
return 'http://{host}:{port}{path}'.format(
host=host,
port=self.port,
path=self.path,
)
def _lazyCall(self, name, *args, **kwargs):
if self._client is None:
self._connect()
# TODO: Automatically connect on timed out connections
return getattr(self._client, name)(*args, **kwargs)
def __getattr__(self, name):
getattr(self.module.Client, name)
return partial(self._lazyCall, name)
class Connection(object):
"""
Class to manage basic transport and protocol.
User should not use instances of this class directly.
The instances should be managed by a Client object.
"""
def __init__(self,
host,
port,
transport_type,
protocol_type,
retry_timeout,
retry_times,
use_ssl,
use_http,
authentication,
keep_alive=False):
self.host = host
self.port = port
self.use_ssl = use_ssl
self.use_http = use_http
self.authentication = authentication
self.keep_alive = keep_alive
self._transport_type = THRIFT_TRANSPORTS[transport_type]
self._protocol_type = THRIFT_PROTOCOLS[protocol_type]
self._retry_timeout = retry_timeout
self._retry_times = retry_times
self._rebuild_protocol()
self._initialized = True
def _rebuild_protocol(self):
"""
Rebuild the transport, protocol from the configuration.
Should not be used directly by users.
Returns:
None
"""
if self.use_http:
# if use http transport,
prefix = 'https://' if self.use_ssl else 'http://'
self.transport = THttpClient(uri_or_host=prefix + self.host + ':' +
str(self.port))
self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
return
if self.use_ssl:
from thrift.transport.TSSLSocket import TSSLSocket
socket = TSSLSocket(host=self.host,
port=self.port,
validate=False,
socket_keepalive=self.keep_alive)
else:
socket = TSocket(host=self.host,
port=self.port,
socket_keepalive=self.keep_alive)
if self.authentication:
socket = TSaslClientTransport(
socket,
host=self.host,
service=self.authentication.service,
mechanism=self.authentication.mechanism,
username=self.authentication.username,
password=self.authentication.password,
)
self.transport = self._transport_type(socket)
self.protocol = self._protocol_type(self.transport)
def is_open(self):
return self.transport.isOpen()
def open(self):
if self.transport.isOpen():
return
logger.debug("Opening thrift transport throught TCP connection.")
self.transport.open()
def close(self):
if not self.transport.isOpen():
return
if logger is not None:
logger.debug("Closing thrift transport to {}:{}.".format(
self.host, self.port))
self.transport.close()
def _reconnect(self):
"""
Method to rebuild the connection with thrift server. Should not be used by the user directly.
Returns: None
"""
if not self.transport.isOpen():
logger.info(
"Connection lose is detected and start reconnecting to the target thrift server."
)
for i in range(self._retry_times):
if self.transport.isOpen():
logger.info(
"Reconnection success after retrying {} times.".format(
i))
return True
self._rebuild_protocol()
try:
logger.info("Starting reconnection to thrift server.")
self.transport.open()
logger.info(
"Reconnection success after retrying {} times.".format(
i + 1))
return True
except TTransportException:
logger.error("Reconnected {} times but failed.".format(i +
1))
time.sleep(self._retry_timeout)
if not self.transport.isOpen():
logger.error(
"Failed to rebuild connection with target thrift server.")
raise TTransportException(
type=TTransportException.NOT_OPEN,
message=
"Failed to rebuild connection with target thrift server.")
return False
def __init__(self,
host='manager',
port=40002,
protocol=Protocol.THRIFT_TCP,
request_client=None,
response_client=None,
ticket_client=None,
loop=asyncio.get_event_loop()):
init_mapper()
self._loop = loop
self._request_client = None
self._ticket_client = None
self._response_client = None
if request_client is not None and response_client is not None and ticket_client is not None:
self._request_client = request_client
self._response_client = response_client
self._ticket_client = ticket_client
else:
if protocol == Protocol.THRIFT_TCP:
transport = TSocket.TSocket(host, port)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
protocol_request = TMultiplexedProtocol.TMultiplexedProtocol(
protocol, self.THRIFT_SERVICE_NAME_REQUEST)
protocol_ticket = TMultiplexedProtocol.TMultiplexedProtocol(
protocol, self.THRIFT_SERVICE_NAME_TICKET)
protocol_response = TMultiplexedProtocol.TMultiplexedProtocol(
protocol, self.THRIFT_SERVICE_NAME_RESPONSE)
self._request_client = ExecLogicService.Client(
protocol_request)
self._ticket_client = TicketService.Client(protocol_ticket)
self._response_client = ExecLogicResponseService.Client(
protocol_response)
transport.open()
elif protocol == Protocol.REST:
self._request_client = RESTExecLogicService(host, port)
self._response_client = RESTExecLogicResponseService(
host, port)
self._ticket_client = RESTTicketService(host, port)
elif protocol == Protocol.THRIFT_HTTP:
transport_request = THttpClient('http://{}:{}/{}'.format(
host, port, self.THRIFT_SERVICE_NAME_REQUEST))
transport_response = THttpClient('http://{}:{}/{}'.format(
host, port, self.THRIFT_SERVICE_NAME_RESPONSE))
transport_ticket = THttpClient('http://{}:{}/{}'.format(
host, port, self.THRIFT_SERVICE_NAME_TICKET))
protocol_request = TBinaryProtocol.TBinaryProtocol(
transport_request)
protocol_response = TBinaryProtocol.TBinaryProtocol(
transport_response)
protocol_ticket = TBinaryProtocol.TBinaryProtocol(
transport_ticket)
self._request_client = ExecLogicService.Client(
protocol_request)
self._response_client = ExecLogicResponseService.Client(
protocol_response)
self._ticket_client = TicketService.Client(protocol_ticket)
transport_request.open()
transport_response.open()
transport_ticket.open()
def get_protocol(host, endpoint, headers={}):
transport = THttpClient(host + endpoint)
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
return protocol
class ThriftClient(object):
"""Base Class for easy interfacing with thrift services.
`ThriftClient` can be used directly, or subclassed. If subclassed,
you can override a variety of attributes in order to make instantiation
more natural:
MODULE - The generated thrift module. Should include Iface and Client
HOST - A default host to connect to. Possibly a vip.
PORT - A default port to connect to.
PATH - An http path to request. Enables HTTP client mode.
TRANSPORT_CLASS - By default, `TFramedTransport` for socket servers,
`TBufferedTransport` for HTTP servers.
PROTOCOL_CLASS - By default, `TBinaryProtocol`
CONNECT_TIMEOUT - By default, 3.0 seconds
Instantiation should be done via the class methods, `for_hostport()`, and
`for_localhost()` as appropriate. These helpers more aggressively require
`port` and `host` arguments as appropriate. Generic construction arguments
override the class attribute defaults:
`module` - Generated thrift module.
`host` - IP address to connect to.
`port` - Port to connect to.
`path` - HTTP URI path to request. Enables HTTP client mode.
`connect_timeout` - Socket connection timeout
`transport_class` - Thrift transport class
`protocol_class` - Thrift protocol class
Additional features are configurable with other arguments:
`lazy` - Default: True, connect on first RPC invocation, instead of
at construction time.
Connections are made lazily, when the first rpc invocation occurs, so you
do need to wrap client instantiation with a try-catch.
"""
MODULE = None
HOST = None
PORT = None
PATH = None
TRANSPORT_CLASS = None
PROTOCOL_CLASS = TBinaryProtocol
CONNECT_TIMEOUT = 3.0
@classmethod
def for_hostport(cls, host=None, port=None, **kwargs):
assert host or cls.HOST, "You must define a host!"
assert port or cls.PORT, "You must define a port!"
return cls(host=host, port=port, **kwargs)
@classmethod
def for_localhost(cls, port=None, **kwargs):
assert port or cls.PORT, "You must define a port!"
return cls(host='127.0.0.1', port=port, **kwargs)
def _initAttribute(self, name, value, *defaults):
defaults = list(defaults)
while value is None and len(defaults):
value = defaults.pop(0)
setattr(self, name, value)
def __init__(self, host=None, port=None, module=None, lazy=True,
connect_timeout=None, transport_class=None,
protocol_class=None, path=None):
self._initAttribute('host', host, self.HOST)
self._initAttribute('port', port, self.PORT)
self._initAttribute('path', path, self.PATH)
self._initAttribute('module', module, self.MODULE)
self._initAttribute('connect_timeout', connect_timeout,
self.CONNECT_TIMEOUT)
# For non-http, default should be TFramed, for http, default TBuffered
if self.path is None:
fallback_transport = TFramedTransport
else:
fallback_transport = TBufferedTransport
self._initAttribute('transport_class', transport_class,
self.TRANSPORT_CLASS, fallback_transport)
self._initAttribute('protocol_class', protocol_class,
self.PROTOCOL_CLASS)
self.lazy = lazy
assert self.module is not None, "You must define a thrift module!"
if self.lazy:
self._client = None
else:
self._connect()
def _connect(self):
if self.path is None:
self._socket = TSocket(self.host, self.port)
else:
self._socket = THttpClient(self._makeConnectURI())
self._socket.setTimeout(int(self.connect_timeout * 1000))
self._transport = self.transport_class(self._socket)
self._protocol = self.protocol_class(self._transport)
self._client = self.module.Client(self._protocol)
self._transport.open()
def _makeConnectURI(self):
assert self.path.startswith('/')
host = self.host
# If host is a v6 addr, we need to format the URI a little bit
# differently in order to parse its port out according to spec
if ':' in host:
assert sys.version >= '2.7', \
"Native v6 IP URLs not parseable on Python < 2.7"
host = '[{host}]'.format(host=host)
return 'http://{host}:{port}{path}'.format(
host=host,
port=self.port,
path=self.path,
)
def _lazyCall(self, name, *args, **kwargs):
if self._client is None:
self._connect()
# TODO: Automatically connect on timed out connections
return getattr(self._client, name)(*args, **kwargs)
def __getattr__(self, name):
getattr(self.module.Client, name)
return partial(self._lazyCall, name)
from __future__ import absolute_import
from thrift.transport.THttpClient import THttpClient
from thrift.protocol.TBinaryProtocol import TBinaryProtocolAccelerated
from ping import Ping
trans = THttpClient('http://localhost:8888/thrift')
proto = TBinaryProtocolAccelerated(trans)
client = Ping.Client(proto)
print client.ping('world')
def __init__(self, my_app, my_token=None):
self.lineServer = "https://ga2.line.naver.jp"
self.lineOBS = "https://obs-sg.line-apps.com"
self.boteaterApi = "https://api.boteater.us"
self.liffServer = "https://api.line.me/message/v3/share"
self.stickerLink = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.stickerLinkAnimation = "https://stickershop.line-scdn.net/stickershop/v1/sticker/{}/iPhone/[email protected]"
self.dataHeaders = self.readJson("headers.json")
if my_app in self.dataHeaders:
self.headers = self.dataHeaders[my_app]
if my_token != None:
self.headers["X-Line-Access"] = my_token
else:
del self.headers["X-Line-Access"]
self.headers["X-Line-Access"] = self.qrLogin(self.headers)
#self.headers["X-Line-Access"] = self.qrLoginRotate("ios_ipad")
else:
raise Exception('APP not found!!!')
### CONNECT TO POOL ###
transport = THttpClient(self.lineServer + '/P4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.pool = BoteaterService.Client(protocol)
### CONNECT TO TALK ###
transport = THttpClient(self.lineServer + '/api/v4/TalkService.do')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.talk = BoteaterService.Client(protocol)
### CONNECT TO CHANNEL ###
transport = THttpClient(self.lineServer + '/CH4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.channel = BoteaterService.Client(protocol)
### CONNECT TO CALL ###
transport = THttpClient(self.lineServer + '/V4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.call = BoteaterService.Client(protocol)
### CONNECT TO SHOP ###
transport = THttpClient(self.lineServer + '/TSHOP4')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.shop = BoteaterService.Client(protocol)
### CONNECT TO LIFF ###
transport = THttpClient(self.lineServer + '/LIFF1')
transport.setCustomHeaders(self.headers)
transport.open()
protocol = TCompactProtocol(transport)
self.liff = BoteaterService.Client(protocol)
self.profile = self.getProfile()
self.lastOP = self.getLastOpRevision()
self.liffPermision()
self.tokenOBS = self.acquireEncryptedAccessToken()
print("[ Login ] Display Name: " + self.profile.displayName)
### TIMELINE HEADERS ###
self.tl_headers= copy.deepcopy(self.headers)
self.tl_headers["X-Line-ChannelToken"] = self.issueChannelToken('1341209950').channelAccessToken
self.tl_headers["X-Line-Mid"] = self.profile.mid
self.tl_headers["X-Line-AcceptLanguage"] = 'en'
self.tl_headers["X-Requested-With"] = 'jp.naver.line.android.LineApplication'
self.tl_headers["Content-Type"] = 'application/json'
def openTransport(self, endPoint):
transport = THttpClient(self.lineServer + endPoint)
transport.setCustomHeaders(self.thisHeaders)
protocol = TCompactProtocol(transport)
return TalkService.Client(protocol)
def qrLogin():
headers= {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36",
"X-Line-Application": "CHROMEOS\t2.3.2\tChrome OS\t1",
"x-lal": "en_ID",
"X-Line-Carrier": "51010,1-0"
}
sys_name = "BE-Team"
transport = THttpClient("https://ga2.line.naver.jp" + '/api/v4/TalkService.do')
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
talk = BoteaterService.Client(protocol)
qr_code = talk.getAuthQrcode(keepLoggedIn=True, systemName=sys_name, returnCallbackUrl=True)
transport.close()
print(qr_code.callbackUrl)
headers["X-Line-Access"] = qr_code.verifier
transport = THttpClient("https://ga2.line.naver.jp" + '/api/v4p/rs')
transport.setCustomHeaders(headers)
protocol = TCompactProtocol(transport)
auth = BoteaterService.Client(protocol)
get_access = json.loads(requests.get("https://ga2.line.naver.jp" + '/Q', headers=headers).text)
login_request = LoginRequestStruct()
login_request.type = 1
login_request.identityProvider = 1
login_request.keepLoggedIn = True
login_request.systemName = sys_name
login_request.verifier = get_access['result']['verifier']
result = auth.loginZ(login_request)
transport.close()
return result.authToken
