#!/usr/bin/env python
#-*-coding: utf-8 -*-

import os, sys, json
from struct import pack, unpack
from time import strptime, mktime
from syslog import syslog, LOG_ERR

debug = False
def log_debug(*args):
	if debug:
		print >> sys.stderr, ' '.join(args)

def _is_scoket_exception(e):
	import socket
	if type(e) == socket.gaierror or type(e) == socket.error or type(e) == socket.herror or type(e) == socket.timeout:
		return True
	return False

def _convert_socket_error_code(message):
	error_code = -1
	if -1 != message.find("[Errno -2] Name or service not known"):
		error_code = -2
	elif -1 != message.find("[Errno -3] Temporary failure in name resolution"):
		error_code = -2
	elif -1 != message.find("[Errno -5] No address associated with hostname"):
		error_code = -2
	elif -1 != message.find("[Errno 110] Connection timed out"):
		error_code = 408
	elif -1 != message.find("[Errno 101] Network is unreachable"):
		error_code = -4
	elif -1 != message.find("[Errno 111] Connection refused"):
		error_code = -4
	elif -1 != message.find("[Errno 113] No route to host"):
		error_code = -4
	elif -1 != message.find("[Errno 104] Connection reset by peer"):
		error_code = -4
	elif -1 != message.find("[Errno 32] Broken pipe"):
		error_code = 408
	return error_code

def _is_ssl_timeout(message):
	#ssl.SSLErr_timeouteption log
	if -1 != message.find("timed out"):
		# The read operation timed out
		# The write operation timed out
		# The handshake operation timed out
		return True
	return False

def _convert_socket_exception(e):
	import socket

	error_code = -1
	error_msg = 'Unknown'
	error_cls = 'Unknown'

	try:
		error_cls = type(e).__name__
		if hasattr(e, '__module__') and e.__module__:
			error_cls = e.__module__ + '.' + error_cls

		if type(e) == socket.gaierror:
			if hasattr(e, 'strerror') and e.strerror:
				error_msg = e.strerror
			if e.errno == -2:
				# socket.gaierror: [Errno -2] Name or service not known
				# 1. dns not set
				# 2. set to a wrong dns
				error_code = -2
			elif e.errno == -3:
				# socket.gaierror: [Errno -3] Temporary failure in name resolution
				# man gai_strerror, and find EAI_AGAIN:
				# The name server returned a temporary failure indication.  Try again later.
				error_code = -2
			elif e.errno == -5:
				# socket.gaierror: [Errno -5] No address associated with hostname
				# man gai_strerror, and find EAI_NODATA:
				# The specified network host exists, but does not have any network addresses defined.
				error_code = -2
			elif e.errno < 100 and e.errno > 0:
				error_code = e.errno
		elif type(e) == socket.error or type(e) == socket.herror:
			if hasattr(e, 'strerror') and e.strerror:
				error_msg = e.strerror
			elif hasattr(e, 'args'):
				error_msg = str(e.args)
				if -1 != error_msg.find('Tunnel connection failed'):
					error_code = -4

			if e.errno == socket.errno.ETIMEDOUT:
				# socket.error: [Errno 110] Connection timed out
				error_code = 408
			elif e.errno == socket.errno.ENETUNREACH:
				# socket.error: [Errno 101] Network is unreachable
				error_code = -4
			elif e.errno == socket.errno.ECONNREFUSED:
				# socket.error: [Errno 111] Connection refused
				error_code = -4
			elif e.errno == socket.errno.EHOSTUNREACH:
				# socket.error: [Errno 113] No route to host
				error_code = -4
			elif e.errno == socket.errno.ECONNRESET:
				# socket.error: [Errno 104] Connection reset by peer
				error_code = -4
			elif e.errno == socket.errno.EPIPE:
				# socket.error: [Errno 32] Broken pipe
				error_code = 408
			elif e.errno < 100 and e.errno > 0:
				error_code = e.errno
			#syslog(LOG_ERR, "get network error %d:%s" % (e.errno, error_msg))
		elif type(e) == socket.timeout:
			error_msg = 'timed out'
			error_code = 408
		else:
			syslog(LOG_ERR, "BUG: exception [%s], type [%s]" % (str(e), type(e)))
		#syslog(LOG_ERR, "error %s:%d:%s" % (error_cls, error_code, str(error_msg)))

		if -1 == error_code:
			if hasattr(e, "args"):
				syslog(LOG_ERR, "error args: [%s]" % (str(e.args)))
			if hasattr(e, "errno"):
				syslog(LOG_ERR, "error errno: [%s]" % (str(e.errno)))
			if hasattr(e, "strerror"):
				syslog(LOG_ERR, "error strerror: [%s]" % (str(e.strerror)))
	except Exception as ee:
		syslog(LOG_ERR, "parse socket exception failed: [%s]" % (str(ee)))
		pass

	return {
		'success': False,
		'error_class': error_cls,
		'error_message': error_msg,
		'error_code': error_code
	}
def _convert_exception(e):
	import swiftclient
	import keystoneclient
	import requests
	import socket
	import httplib
	import ssl

	error_code = -1
	error_msg = 'Unknown'
	error_cls = 'Unknown'

	try:
		error_cls = type(e).__name__
		if hasattr(e, '__module__') and e.__module__:
			error_cls = e.__module__ + '.' + error_cls

		try:
			if type(e.message) is unicode:
				error_msg = repr(e.message).split('\\n')[0]
			else:
				error_msg = str(e.message).split('\n')[0]
			log_debug("\033[31mexception: \033[0m", error_msg)
		except:
			log_debug("\033[31mexception: \033[0m", "could not parse error msg")
		if type(e) == swiftclient.ClientException:
			if hasattr(e, "http_status"):
				if e.http_status == 400 and e.message == "Refresh access token failed":
					error_code = 401
				elif e.http_status >= 100 and e.http_status < 700:
					error_code = e.http_status
		elif type(e) == keystoneclient.exceptions.SSLError:
			error_code = -4
		elif type(e) == keystoneclient.exceptions.RequestTimeout:
			error_code = 408
		elif type(e) == keystoneclient.exceptions.ConnectionRefused:
			error_code = _convert_socket_error_code(str(e))
		elif type(e) == keystoneclient.exceptions.BadRequest:
			if hasattr(e, "http_status"):
				error_code = e.http_status
			if hasattr(e, "message"):
				error_msg = e.message
			if error_code == 400 and (error_msg == "Username should not contain white spaces" \
					or error_msg == 'Expecting username' or error_msg == 'Expecting apiKey'):
				error_code = 401
		elif type(e) == TypeError:
			# this exception will raise when base64 decode for auth failed
			if error_msg == "Incorrect padding":
				error_code = 401
		elif type(e) == UnicodeDecodeError:
			error_code = -5
		elif type(e) == requests.exceptions.ConnectionError:
			error_code = -4
			if type(e.args[0]) == requests.packages.urllib3.exceptions.ProtocolError:
				if "BadStatusLine" in str(e.args[0]):
					error_code = -4
				elif _is_scoket_exception(e.args[0].args[1]):
					return _convert_socket_exception(e.args[0].args[1])
				else:
					syslog(LOG_ERR, "ProtocolError: exception [%s], type [%s]" % (str(e.args[0].args[1]), type(e.args[0].args[1])))
			elif type(e.args[0]) == requests.packages.urllib3.exceptions.MaxRetryError:
				if hasattr(e.args[0], 'reason') and e.args[0].reason:
					if type(e.args[0].reason) == requests.packages.urllib3.exceptions.NewConnectionError:
						error_code = _convert_socket_error_code(str(e.args[0].reason))
					else:
						syslog(LOG_ERR, "MaxRetryError: exception [%s], type [%s]" % (str(e.args[0].reason), type(e.args[0].reason)))
			elif _is_scoket_exception(e.args[0]):
				return _convert_socket_exception(e.args[0])
			elif type(e.args[0]) == ssl.SSLError or type(e.args[0]) == requests.packages.urllib3.exceptions.SSLError:
				if hasattr(e.args[0], 'message') and e.args[0].message:
					error_msg = e.args[0].message
				if _is_ssl_timeout(str(error_msg)):
					error_code = 408
				else:
					syslog(LOG_ERR, "SSLError: exception [%s], type [%s]" % (str(error_msg), type(error_msg)))
		elif type(e) == requests.exceptions.SSLError:
			error_code = -4
			# EOF occurred in violation of protocol
			# SSL: DECRYPTION_FAILED_OR_BAD_RECORD_MAC
			# SSL: SSLV3_ALERT_BAD_RECORD_MAC
			# SSL: SSLV3_ALERT_ILLEGAL_PARAMETER
			# SSL: TLSV1_ALERT_DECRYPT_ERROR
			# SSL: TLSV1_ALERT_DECODE_ERROR
			# SSL: CERTIFICATE_VERIFY_FAILED
			if _is_ssl_timeout(str(e)):
				error_code = 408
		elif type(e) == requests.packages.urllib3.exceptions.NewConnectionError:
			error_code = _convert_socket_error_code(str(e))
		elif type(e) == requests.packages.urllib3.exceptions.ConnectTimeoutError:
			error_code = 408
		elif type(e) == requests.packages.urllib3.exceptions.ReadTimeoutError:
			error_code = 408
		elif type(e) == requests.exceptions.ConnectTimeout:
			error_code = 408
		elif type(e) == requests.exceptions.ReadTimeout:
			error_code = 408
		elif type(e) == httplib.ResponseNotReady:
			error_code = -4
		elif type(e) == httplib.BadStatusLine:
			error_code = -4
		elif type(e) == httplib.IncompleteRead:
			error_code = -4
		elif type(e) == ssl.SSLError:
			error_code = -4
			if hasattr(e, "strerror") and e.strerror:
				# SSL: DECRYPTION_FAILED_OR_BAD_RECORD_MAC
				# SSL: SSLV3_ALERT_BAD_RECORD_MAC
				# SSL: CERTIFICATE_VERIFY_FAILED
				error_msg = e.strerror
			if _is_ssl_timeout(str(error_msg)):
				error_code = 408
		elif type(e) == ssl.SSLEOFError:
			# ssl.SSLEOFError: [Errno 8] EOF occurred in violation of protocol
			if hasattr(e, 'strerror') and e.strerror:
				error_msg = e.strerror
			error_code = -4
		elif type(e) == IOError:
			if hasattr(e, 'strerror') and e.strerror:
				error_msg = e.strerror
			error_code = _convert_socket_error_code(str(e))
		elif _is_scoket_exception(e):
			return _convert_socket_exception(e)
		else:
			syslog(LOG_ERR, "exception [%s]" % str(e))
			syslog(LOG_ERR, "type [%s]" % type(e))
		#syslog(LOG_ERR, "error %s:%d:%s" % (error_cls, error_code, str(error_msg)))

		if -1 == error_code:
			if hasattr(e, "args"):
				syslog(LOG_ERR, "error args: [%s]" % (str(e.args)))
			if hasattr(e, "errno"):
				syslog(LOG_ERR, "error errno: [%s]" % (str(e.errno)))
			if hasattr(e, "strerror"):
				syslog(LOG_ERR, "error strerror: [%s]" % (str(e.strerror)))
	except Exception as ee:
		syslog(LOG_ERR, "parse exception failed: [%s]" % (str(ee)))
		pass

	return {
		'success': False,
		'error_class': error_cls,
		'error_message': error_msg,
		'error_code': error_code
	}
def _convert_GMT_time_str(val):
	origin_tz = None
	if os.environ.get('TZ'):
		origin_tz = os.environ.get('TZ')
	os.environ['TZ'] = 'GMT'

	timestamp = int(mktime(strptime(val, '%a, %d %b %Y %H:%M:%S %Z')))

	if origin_tz:
		os.environ['TZ'] = origin_tz
	return timestamp
def _convert_UTC_time_str(val):
	origin_tz = None
	if os.environ.get('TZ'):
		origin_tz = os.environ.get('TZ')
	os.environ['TZ'] = 'UTC'

	time_val, sec_xtime = str(val).split('.')
	timestamp = int(mktime(strptime(time_val, '%Y-%m-%dT%H:%M:%S')))

	sec_xtime = sec_xtime.rstrip('Z')
	if int(sec_xtime) > 0:
		timestamp += 1

	if origin_tz:
		os.environ['TZ'] = origin_tz
	return timestamp
def _convert_properties(properties):
	out_json = {
		# 2015-10-01T02:52:24.169600 / 1443667944.169600 -> 1443667945
		'LastModified': _convert_UTC_time_str(properties.get('last_modified')),
		'ETag': properties.get('hash'),
		'ContentType': properties.get('content_type'),
		'ContentLength': properties.get('bytes')
	}
	return out_json
def _convert_properties_by_dict(properties):
	out_json = {
		'LastModified': _convert_GMT_time_str(properties.get('last-modified')),
		'ETag': properties.get('etag'),
		'ContentType': properties.get('content-type'),
		'ContentLength': properties.get('content-length')
	}
	return out_json

class SimpleIO(object):
	def read_int(self):
		data = ''
		n = 4
		while n > 0:
			read_data = sys.stdin.read(n)
			if 0 == len(read_data):
				raise StopIteration
			data += read_data
			n -= len(read_data)
		if data:
			return unpack('i', data)[0]
		else:
			# check eof?
			raise StopIteration
	def read_string(self):
		n = self.read_int()
		if 0 == n:
			return ''
		data = ''
		while n > 0:
			read_data = sys.stdin.read(n)
			data += read_data
			n -= len(read_data)
		if data:
			return data
		else:
			raise SystemError
	def read_json(self):
		json_str = self.read_string()
		if json_str:
			return json.loads(json_str)
		else:
			return None
	def write_int(self, val):
		data = pack('i', val)
		sys.stdout.write(data)
		sys.stdout.flush()
	def write_string(self, val):
		self.write_int(len(val))
		sys.stdout.write(val)
		sys.stdout.flush()
		# log
	def write_json(self, val):
		s = json.dumps(val)
		self.write_string(s)
	def write_exception(self, e):
		self.write_json(_convert_exception(e))

class FileObjectWithProgress(object):
	"""
	Readable file object with progress wrapper.
	"""

	def __init__(self, io):
		"""
		Wrap the underlying file object

		:param file_obj: the file object to wrap
		"""
		self._io = io
		self._file_obj = None
		self._prev_process_size = 0

	def set_file_obj(self, file_obj):
		self._file_obj = file_obj
		self._prev_process_size = 0

	def read(self, length=None):
		read_data = self._file_obj.read(length)
		self._prev_process_size += len(read_data)

		res = {
			'success': True,
			'complete': False,
			'uploaded': self._prev_process_size
		}
		if self._io:
			self._io.write_json(res)
		else:
			print res
		return read_data

	def write(self, write_data):
		self._file_obj.write(write_data)
		self._prev_process_size += len(write_data)

		res = {
			'success': True,
			'complete': False,
			'downloaded': self._prev_process_size
		}
		if self._io:
			self._io.write_json(res)
		else:
			print res
		return None
	def tell(self):
		return self._file_obj.tell();
	def seek(self, offset, whence=os.SEEK_SET):
		self._file_obj.seek(offset, whence)

class OpenStackSwiftApi(object):
	def __init__(self, io=None):
		import swiftclient

		self._file_obj_progress = FileObjectWithProgress(io)
		self._io = io
		SYNO_SOCKET_TIMEOUT = 600

		#os.environ['SWIFT_DEBUG'] = 1
		self._swift = swiftclient.Connection(
			authurl=os.environ.get('OPENSTACK_SWIFT_URL'),
			user=os.environ.get('OPENSTACK_SWIFT_USER'),
			key=os.environ.get('OPENSTACK_SWIFT_KEY'),
			retries=int(os.environ.get('OPENSTACK_SWIFT_RETRIES')),
			preauthurl=os.environ.get('OPENSTACK_SWIFT_PREAUTHURL'),
			preauthtoken=os.environ.get('OPENSTACK_SWIFT_PREAUTHTOKEN'),
			auth_version=os.environ.get('OPENSTACK_SWIFT_VERSION'),
			os_options={
				'tenant_id': os.environ.get('OPENSTACK_SWIFT_TENANT_ID'),
				'tenant_name': os.environ.get('OPENSTACK_SWIFT_TENANT_NAME'),
				'user_domain_id': os.environ.get('OPENSTACK_SWIFT_DOMAIN_ID'),
				'user_domain_name': os.environ.get('OPENSTACK_SWIFT_DOMAIN_NAME'),
				'region_name': os.environ.get('OPENSTACK_SWIFT_REGION')
			},
			timeout=SYNO_SOCKET_TIMEOUT)
		self._service_options={
			'auth': os.environ.get('OPENSTACK_SWIFT_URL'),
			'user': os.environ.get('OPENSTACK_SWIFT_USER'),
			'key': os.environ.get('OPENSTACK_SWIFT_KEY'),
			'retries': int(os.environ.get('OPENSTACK_SWIFT_RETRIES')),
			'auth_version': os.environ.get('OPENSTACK_SWIFT_VERSION'),
			'os_tenant_id': os.environ.get('OPENSTACK_SWIFT_TENANT_ID'),
			'os_tenant_name': os.environ.get('OPENSTACK_SWIFT_TENANT_NAME'),
			'os_user_domain_id': os.environ.get('OPENSTACK_SWIFT_DOMAIN_ID'),
			'os_user_domain_name': os.environ.get('OPENSTACK_SWIFT_DOMAIN_NAME'),
			'os_auth_token': os.environ.get('OPENSTACK_SWIFT_PREAUTHTOKEN'),
			'os_storage_url': os.environ.get('OPENSTACK_SWIFT_PREAUTHURL'),
			'os_region_name': os.environ.get('OPENSTACK_SWIFT_REGION')}
		self._swift_service = None

		del os.environ['OPENSTACK_SWIFT_VERSION']
		del os.environ['OPENSTACK_SWIFT_URL']
		del os.environ['OPENSTACK_SWIFT_USER']
		del os.environ['OPENSTACK_SWIFT_KEY']
		del os.environ['OPENSTACK_SWIFT_RETRIES']
		del os.environ['OPENSTACK_SWIFT_TENANT_ID']
		del os.environ['OPENSTACK_SWIFT_TENANT_NAME']
		del os.environ['OPENSTACK_SWIFT_DOMAIN_ID']
		del os.environ['OPENSTACK_SWIFT_DOMAIN_NAME']
		del os.environ['OPENSTACK_SWIFT_REGION']
		del os.environ['OPENSTACK_SWIFT_PREAUTHURL']
		del os.environ['OPENSTACK_SWIFT_PREAUTHTOKEN']
		log_debug('agent created')

	def getAuth(self, in_json):
		storage_url, token = self._swift.get_auth()

		return {
			'success': True,
			'token': token,
			'endpoint': storage_url
		}
	def getAuthInfo(self, in_json):
		storage_url, token = self._swift.get_auth_info()
		if not storage_url or not token:
			return {
				'success': False
			}
		return {
			'success': True,
			'token': token,
			'endpoint': storage_url
		}

	def getCapabilities(self, in_json):
		res = self._swift.get_capabilities()

		return {
			'success': True,
			'capabilities': res
		}

	def headAccount(self, in_json):
		headers = self._swift.head_account()

		# 404 not found
		return {
			'success': True,
			'account': headers
		}
	def listRegions(self, in_json):
		regions = self._swift.get_region()

		out_json = {
			'success': True,
			'region': []
		}
		for r in regions:
			out_json['region'].append({
				'Name': r
			})

		return out_json
	def putContainer(self, in_json):
		res = {}
		self._swift.put_container(
			container=in_json['container'],
			response_dict=res)

		code = res.get('status')
		# 201 Created
		# 202 Accepted (exist)
		# 204 Normal response
		# 400 name len > 256
		if code == 201 or code == 204:
			return {'success': True, 'error_code': code, 'error_message': res.get('reason')}
		else:
			return {'success': False, 'error_code': code, 'error_message': res.get('reason')}
	def headContainer(self, in_json):
		headers = self._swift.head_container(in_json['container'])

		# 404 not found
		return {
			'success': True,
			'LastModified': _convert_GMT_time_str(headers.get('date'))
		}
	def listContainers(self, in_json):
		headers, containers = self._swift.get_account(
			full_listing=True)

		out_json = {
			'success': True,
			'container': []
		}
		for c in containers:
			out_json['container'].append({
				'Name': c.get('name')
			})

		return out_json
	def deleteContainer(self, in_json):
		res = {}
		self._swift.delete_container(
			container=in_json['container'],
			response_dict=res)

		code = res.get('status')
		# 204 Normal response
		# 404 not found
		# 409 conflict
		if code == 204:
			return {'success': True, 'error_code': code, 'error_message': res.get('reason')}
		else:
			return {'success': False, 'error_code': code, 'error_message': res.get('reason')}
	def putObject(self, in_json):
		res = {}
		with open(in_json['fileInput'], "rb") as stream:
			self._file_obj_progress.set_file_obj(stream)
			self._swift.put_object(
				container=in_json['container'],
				obj=in_json['name'],
				contents=self._file_obj_progress,
				response_dict=res)

		code = res.get('status')
		# 201 Normal response
		# 408 timeout
		# 400 name len > 1024
		# 411 length required
		# 413 large file
		# 422 unprocessable entity
		if code == 201:
			return {'success': True, 'error_code': code, 'error_message': res.get('reason'),
					'Properties': _convert_properties_by_dict(res.get('headers'))}
		else:
			return {'success': False, 'error_code': code, 'error_message': res.get('reason')}
	def putDirectory(self, in_json):
		res = {}
		self._swift.put_object(
			container=in_json['container'],
			obj=in_json['name'],
			contents='',
			content_type='application/directory',
			response_dict=res)

		code = res.get('status')
		# 201 Normal response
		# 408 timeout
		# 400 name len > 1024
		# 411 length required
		# 413 large file
		# 422 unprocessable entity
		if code == 201:
			return {'success': True, 'error_code': code, 'error_message': res.get('reason')}
		else:
			return {'success': False, 'error_code': code, 'error_message': res.get('reason')}
	def listObjects(self, in_json):
		limit_count = 10000
		marker_obj = in_json.get('Marker', None)
		prefix_obj = in_json.get('Prefix', None)
		delimiter_obj = in_json.get('Delimiter', None)

		headers, objects = self._swift.get_container(
			container=in_json['container'],
			marker=marker_obj,
			limit=limit_count,
			prefix=prefix_obj,
			delimiter=delimiter_obj)

		targetType = in_json.get('TargetType', 'all')
		count = 0
		out_json = {
			'success': True,
			'folder': [],
			'file': []
		}

		for o in objects:
			if targetType == 'folder' or targetType == 'all':
				if o.get('subdir'):
					out_json['folder'].append({'Name': o.get('subdir')})
					count += 1
			if targetType == 'file' or targetType == 'all':
				if o.get('name'):
					out_json['file'].append({
						'Name': o.get('name'),
						'Properties': _convert_properties(o)
					})
					count += 1
		if len(objects) == limit_count:
			if o.get('name'):
				out_json['NextMarker'] = objects[limit_count - 1].get('name')
			else:
				out_json['NextMarker'] = objects[limit_count - 1].get('subdir')
		out_json['count'] = count
		return out_json
	def headObject(self, in_json):
		headers = self._swift.head_object(
			container=in_json['container'],
			obj=in_json['name'])

		properties = _convert_properties_by_dict(headers)
		if "\"" == properties['ETag'][0] and "\"" == properties['ETag'][-1]:
			properties['ETag'] = properties['ETag'][1:-1]

		return {
			'success': True,
			'Properties': properties
		}
	def deleteObject(self, in_json):
		res = {}
		self._swift.delete_object(
			container=in_json['container'],
			obj=in_json['name'],
			response_dict=res)

		code = res.get('status')
		# 204 Normal response
		# 400
		# 404 not found
		# 500
		if code == 204:
			return {'success': True, 'error_code': code, 'error_message': res.get('reason')}
		else:
			return {'success': False, 'error_code': code, 'error_message': res.get('reason')}
	def getObject(self, in_json):
		headers_obj = None
		read_len = 65536
		if in_json.get('RangeStart') and in_json.get('RangeEnd'):
			headers_obj = {'Range': 'bytes=' + in_json.get('RangeStart') + '-' + in_json.get('RangeEnd')}

		hdrs, body = self._swift.get_object(
			container=in_json['container'],
			obj=in_json['name'],
			resp_chunk_size=read_len,
			headers=headers_obj)

		with open(in_json['fileOutput'], "wb") as stream:
			self._file_obj_progress.set_file_obj(stream)
			while True:
				try:
					self._file_obj_progress.write(body.next())
				except StopIteration:
					break

		# 404 not found
		return {'success': True}
	def writeJson(self, res):
		if self._io:
			self._io.write_json(res)
		else:
			print res

	def putLargeObject(self, in_json):
		from swiftclient.service import SwiftService
		from swiftclient.service import SwiftUploadObject
		if self._swift_service is None:
			storage_url, token = self._swift.get_auth_info()
			if storage_url and token:
				self._service_options['os_auth_token'] = token
				self._service_options['os_storage_url'] = storage_url
			self._swift_service = SwiftService(self._service_options)

		generator = self._swift_service.upload(
			container=in_json['container'],
			objects=[SwiftUploadObject(
				source=in_json['fileInput'],
				object_name=in_json['name'])],
			options={
				'segment_size': in_json['segmentSize'],
				'segment_container': in_json['container']})
		for r in generator:
			if r['success']:
				if 'object' in r and 'upload_object' == r['action']:
					if 'manifest_response_dict' in r:
						return {
							'success': True,
							'error_code': r['manifest_response_dict'].get('status'),
							'error_message': r['manifest_response_dict'].get('reason'),
							'Properties': _convert_properties_by_dict(r['manifest_response_dict'].get('headers'))}
					elif 'response_dict' in r:
						return {
							'success': True,
							'error_code': r['response_dict'].get('status'),
							'error_message': r['response_dict'].get('reason'),
							'Properties': _convert_properties_by_dict(r['manifest_response_dict'].get('headers'))}
				elif 'for_object' in r:
					self.writeJson({
						'success': True,
						'complete': False,
						'segment_location': r['segment_location'],
						'segment_size': r['segment_size']})
			else:
				return _convert_exception(r['error'])

	def deleteLargeObject(self, in_json):
		from swiftclient.service import SwiftService
		if self._swift_service is None:
			storage_url, token = self._swift.get_auth_info()
			if storage_url and token:
				self._service_options['os_auth_token'] = token
				self._service_options['os_storage_url'] = storage_url
			self._swift_service = SwiftService(self._service_options)

		res = {}
		generator = self._swift_service.delete(
			container=in_json['container'],
			objects=[in_json['name']])
		for r in generator:
			if r['success']:
				if r['action'] == 'delete_object':
					return {
						'success': True,
						'error_code': r['response_dict'].get('status'),
						'error_message': r['response_dict'].get('reason')}
				#elif r['action'] == 'delete_segment':
				#elif r['action'] == 'delete_container':
			else:
				return _convert_exception(r['error'])

def start_server():
	io = SimpleIO()

	try:
		api = OpenStackSwiftApi(io)
	except Exception as e:
		io.write_exception(e)
		return False

	io.write_string('start')

	while True:
		try:
			in_json = io.read_json()
			fn_name = in_json['fn']
			fn = getattr(api, fn_name)
			del in_json['fn']

			if fn is None:
				raise SystemError('no such fn: ' + fn_name)

			#log_debug('\033[34mexecute: ' + fn_name + ' ' + json.dumps(in_json) + '\033[0m');

			res = fn(in_json)
			io.write_json(res)
		except StopIteration:
			break
		except Exception as e:
			io.write_exception(e)
			continue

if __name__ == '__main__':
	# Under window, there are text mode and binary mode for files,
	# Set binary mode before sending binary data(to stdout)
	# to prevent some unexpected behavior!
	if sys.platform == "win32":
		import os, msvcrt
		msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)

	# add include path
	script_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
	sys.path.insert(0, script_dir + '/swiftclient')
	sys.path.insert(1, script_dir + '/keystoneclient')
	sys.path.insert(2, script_dir + '/module')

	res = start_server()
	sys.exit(0 if res else 1)