def __init__(self, hazelcast_instance_addr, map_name='new'):
self.map_name = map_name
self.client = hazelcast.HazelcastClient(
cluster_name="dev",
cluster_members=hazelcast_instance_addr
)
print('client created')
def do_benchmark():
THREAD_COUNT = 1
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.addresses.append("127.0.0.1:5701")
client = hazelcast.HazelcastClient(config)
my_map = client.get_map("default")
for i in xrange(0, 1000):
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key)
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key, "x" * VALUE_SIZE)
else:
my_map.remove(key)
def setUpClass(cls):
configure_logging()
cls.rc = cls.create_rc()
cls.cluster = cls.create_cluster(cls.rc, cls.configure_cluster())
cls.member = cls.cluster.start_member()
cls.client = hazelcast.HazelcastClient(cls.configure_client(hazelcast.ClientConfig()))
def do_benchmark():
THREAD_COUNT = 1
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
VALUE = "x" * VALUE_SIZE
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.addresses.append("127.0.0.1:5701")
client = hazelcast.HazelcastClient(config)
class ClientThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self, name=name)
self.gets = 0
self.puts = 0
self.removes = 0
self.setDaemon(True)
def run(self):
my_map = client.get_map("default")
while True:
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key)
self.gets += 1
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key, VALUE)
self.puts += 1
else:
my_map.remove(key)
self.removes += 1
threads = [
ClientThread("client-thread-%d" % i) for i in range(0, THREAD_COUNT)
]
for t in threads:
t.start()
start = time.time()
counter = 1
while counter < 1000:
time.sleep(5)
print("ops per second : " + \
str(sum([t.gets + t.puts + t.removes for t in threads]) / (time.time() - start)))
for t in threads:
print("%s: put: %d get: %d: remove: %d" %
(t.name, t.puts, t.gets, t.removes))
counter += 1
def init():
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.addresses.append("127.0.0.1:5701")
near_cache_config = NearCacheConfig(MAP_NAME)
near_cache_config.in_memory_format = IN_MEMORY_FORMAT.OBJECT
config.add_near_cache_config(near_cache_config)
client = hazelcast.HazelcastClient(config)
my_map = client.get_map(MAP_NAME).blocking()
print "START INIT"
for key in xrange(0, ENTRY_COUNT):
my_map.put(key, VALUE)
for key in xrange(0, ENTRY_COUNT):
my_map.get(key)
print "INIT COMPLETE"
return my_map
def init(self):
config = hazelcast.ClientConfig()
for ip in self.ips:
config.network_config.addresses.append(ip + ':5701')
config.group_config.name = self.clusterID
config.group_config.password = self.clusterID
self.client = hazelcast.HazelcastClient(config)
def get_hz_client(groupName, groupPassword, discoveryToken):
config = hazelcast.ClientConfig()
config.group_config.name = groupName
config.group_config.password = groupPassword
config.network_config.cloud_config.enabled = True
config.network_config.cloud_config.discovery_token = discoveryToken
config.set_property("hazelcast.client.cloud.url",
"https://coordinator.hazelcast.cloud")
return hazelcast.HazelcastClient(config)
def test_get_distributed_objects_clears_destroyed_proxies(self):
m = self.client.get_map("map")
six.assertCountEqual(self, [m], self.client.get_distributed_objects())
other_client = hazelcast.HazelcastClient()
other_clients_map = other_client.get_map("map")
other_clients_map.destroy()
six.assertCountEqual(self, [], self.client.get_distributed_objects())
def connect(host_list):
"""
建立hazelcast连接
"""
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
# config.set_property(ClientProperties.INVOCATION_TIMEOUT_SECONDS.name, -1)
for host in host_list:
config.network_config.addresses.append(host)
client = hazelcast.HazelcastClient(config)
return client
def _configure_client(server_list):
config = hazelcast.ClientConfig()
print("Hazelcast Cluster name: {}".format(config.group_config.name))
for peer in server_list:
config.network_config.addresses.append(peer)
client = hazelcast.HazelcastClient(config)
print("Hazelcast Client is {}".format(client.lifecycle.state))
return client
def test_get_distributed_objects_clears_destroyed_proxies(self):
m = self.client.get_map("map")
self.assertTrueEventually(lambda: six.assertCountEqual(
self, [m], self.client.get_distributed_objects()))
other_client = hazelcast.HazelcastClient(**self.config)
other_clients_map = other_client.get_map("map")
other_clients_map.destroy()
self.assertTrueEventually(lambda: six.assertCountEqual(
self, [], self.client.get_distributed_objects()))
other_client.shutdown()
def create_client(self):
logging.basicConfig()
logging.getLogger().setLevel(logging.WARNING)
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.connection_attempt_limit = 1
config.network_config.addresses.append('172.17.42.1:5701')
client = hazelcast.HazelcastClient(config)
return client
def create_client(self):
logging.basicConfig()
logging.getLogger().setLevel(logging.WARNING)
config = hazelcast.ClientConfig()
config.group_config.name = self.options.get('GROUP_NAME', None)
config.group_config.password = self.options.get('GROUP_PASSWORD', None)
config.network_config.connection_attempt_limit = self.options.get(
'CONNECTION_ATTEMPT_LIMIT', 3)
config.network_config.addresses.append(self.server)
client = hazelcast.HazelcastClient(config)
return client
def do_benchmark():
REQ_COUNT = 50000
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.addresses.append("127.0.0.1:5701")
client = hazelcast.HazelcastClient(config)
class Test(object):
def __init__(self):
self.ops = 0
self.event = threading.Event()
def incr(self, _):
self.ops += 1
if self.ops == REQ_COUNT:
self.event.set()
def run(self):
my_map = client.get_map("default")
for _ in xrange(0, REQ_COUNT):
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get_async(key).add_done_callback(self.incr)
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put_async(key, "x" * VALUE_SIZE).add_done_callback(
self.incr)
else:
my_map.remove_async(key).add_done_callback(self.incr)
t = Test()
start = time.time()
t.run()
t.event.wait()
time_taken = time.time() - start
print("Took %s seconds for %d requests" % (time_taken, REQ_COUNT))
print("ops per second: %s" % (t.ops / time_taken))
def main():
hosts = ['localhost:5701', 'localhost:5702', 'localhost:5703']
config = config_client(hosts)
client = hazelcast.HazelcastClient(config)
map_create(client)
map_add(client, {'IPhone X': 899})
# map_add(client, 'IPhone 8', 799)
# map_add(client, 'Galaxy S9+', 899)
# map_add(client, '1', 1)
# map_add(client, '2', 2)
# map_add(client, '3', 3)
# map_add(client, '4', 4)
# map_add(client, '5', 5)
map_show(client)
client.shutdown()
def run(self):
client = hazelcast.HazelcastClient(config)
my_map = client.get_map("default")
while True:
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key)
self.counts[0] += 1
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key, "x" * VALUE_SIZE)
self.counts[1] += 1
else:
my_map.remove(key)
self.counts[2] += 1
def setup(cls, **kwargs):
""" Setup. Called once """
for k, v in kwargs.items():
setattr(cls, k, v)
import socket
socket.setdefaulttimeout(1.0)
import hazelcast
config = hazelcast.ClientConfig()
config.group_config.name = "fanficbook"
config.group_config.password = "******"
config.properties["hazelcast.client.heartbeat.interval"] = 1000
config.properties["hazelcast.client.heartbeat.timeout"] = 15000
for server in cls.servers:
config.network_config.addresses.append(server)
client = hazelcast.HazelcastClient(config)
cls.cache = client.get_map("cherrypy").blocking()
def do_benchmark():
THREAD_COUNT = 1
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
try:
from tests.hzrc.client import HzRemoteController
rc = HzRemoteController('127.0.0.1', '9701')
if not rc.ping():
logger.info("Remote Controller Server not running... exiting.")
exit()
logger.info("Remote Controller Server OK...")
rc_cluster = rc.createCluster(None, None)
rc_member = rc.startMember(rc_cluster.id)
config.network.addresses.append('{}:{}'.format(rc_member.host,
rc_member.port))
except (ImportError, NameError):
config.network.addresses.append('127.0.0.1')
client = hazelcast.HazelcastClient(config)
my_map = client.get_map("default")
for i in range(0, 1000):
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key)
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key, "x" * VALUE_SIZE)
else:
my_map.remove(key)
def main(args):
clientConfig = hazelcast.ClientConfig()
clientConfig.network_config.addresses.append("localhost")
logging.basicConfig()
logging.getLogger().setLevel(logging.INFO)
client = hazelcast.HazelcastClient(clientConfig)
queue = client.get_queue("binary-queue")
while (1):
item = queue.take()
bArr = item.result()
aStr = array.array('B', bArr).tostring()
print(aStr)
def init():
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
config.network_config.addresses.append("127.0.0.1")
near_cache_config = NearCacheConfig(MAP_NAME)
near_cache_config.in_memory_format = IN_MEMORY_FORMAT.OBJECT
config.add_near_cache_config(near_cache_config)
try:
from hzrc.client import HzRemoteController
rc = HzRemoteController('127.0.0.1', '9701')
if not rc.ping():
logger.info("Remote Controller Server not running... exiting.")
exit()
logger.info("Remote Controller Server OK...")
rc_cluster = rc.createCluster(None, None)
rc_member = rc.startMember(rc_cluster.id)
config.network_config.addresses.append('{}:{}'.format(
rc_member.host, rc_member.port))
except (ImportError, NameError):
config.network_config.addresses.append('127.0.0.1')
client = hazelcast.HazelcastClient(config)
my_map = client.get_map(MAP_NAME).blocking()
print "START INIT"
for key in xrange(0, ENTRY_COUNT):
my_map.put(key, VALUE)
for key in xrange(0, ENTRY_COUNT):
my_map.get(key)
print "INIT COMPLETE"
return my_map
def init_client(self, HazelCast_Address):
LOG.info("init hazelcast client...")
self.HazelCast_Address = HazelCast_Address
self.config = hazelcast.ClientConfig()
self.config.serialization_config.portable_factories[FACTORY_ID] = {DFlow.CLASS_ID: DFlow}
self.config.network_config.addresses.append(self.HazelCast_Address)
self.hazelcast_client = hazelcast.HazelcastClient(self.config)
LOG.info("init maps...")
#init maps:d_maps and local_maps
for key in self.map_keys:
self._init_map(key)
#add listener to d_maps:dswitch,dport,dlink,dhost's d_map
self.d_maps[DSWITCH_MAP].add_entry_listener(include_value=True, added=self._dswitch_map_changed,
updated=self._dswitch_map_changed, removed=self._dswitch_map_changed)
self.d_maps[DPORT_MAP].add_entry_listener(include_value=True, added=self._dport_map_changed,
updated=self._dport_map_changed, removed=self._dport_map_changed)
self.d_maps[DLINK_MAP].add_entry_listener(include_value=True, added=self._dlink_map_changed,
updated=self._dlink_map_changed, removed=self._dlink_map_changed)
self.d_maps[DHOST_MAP].add_entry_listener(include_value=True, added=self._dhost_map_changed,
updated=self._dhost_map_changed, removed=self._dhost_map_changed)
self.d_maps[DFLOW_MAP].add_entry_listener(include_value=True, added=self._dflow_map_changed,
updated=self._dflow_map_changed, removed=self._dhost_map_changed)
def _hazelcast_conn(self):
if self.hazelcast_conn:
return (self.hazelcast_conn, 0, '+OK')
import hazelcast
config = hazelcast.ClientConfig()
config.logger_config.level = 100 if settings['LOG_ENABLED'] == False else (settings['HAZELCAST_LOGGER_LEVELS'][settings['LOG_LEVEL']] if settings['LOG_LEVEL'] in settings['HAZELCAST_LOGGER_LEVELS'] else settings['HAZELCAST_LOGGER_LEVELS']['NOTSET'] )
[config.network_config.addresses.append(host) for host in settings['HAZELCAST_HOSTS'] ]
lsterr = None
for _ in range(2):
try:
client = hazelcast.HazelcastClient(config)
self.hazelcast_conn = client
lsterr = None
break
except Exception as e:
lsterr = { "errno": e.errno if 'errno' in e else 1, "errmsg": repr(e)}
time.sleep(0.5)
return (self.hazelcast_conn, 0, '+OK', ) if lsterr is None else (self.hazelcast_conn, lsterr['errno'], lsterr['errmsg'], )
import hazelcast
import logging
import threading
if __name__ == "__main__":
logging.basicConfig()
logging.getLogger().setLevel(logging.INFO)
client = hazelcast.HazelcastClient()
queue = client.get_queue("queue")
def produce():
for i in range(100):
queue.offer("value-" + str(i))
def consume():
consumed_count = 0
while consumed_count < 100:
head = queue.take().result()
print("Consuming {}".format(head))
consumed_count += 1
produce_thread = threading.Thread(target=produce)
consume_thread = threading.Thread(target=consume)
produce_thread.start()
consume_thread.start()
produce_thread.join()
consume_thread.join()
object_data_output.write_float(self.gpa)
def get_factory_id(self):
return self.FACTORY_ID
def get_class_id(self):
return self.CLASS_ID
def __repr__(self):
return "Student(id=%s, name=%s, gpa=%s)" % (self.id, self.name,
self.gpa)
client = hazelcast.HazelcastClient(data_serializable_factories={
Student.FACTORY_ID: {
Student.CLASS_ID: Student
}
})
my_map = client.get_map("map")
student = Student(1, "John Doe", 3.0)
my_map.put("student1", student)
returned_student = my_map.get("student1").result()
print("Received:", returned_student)
client.shutdown()
def read_data(self, object_data_input):
self.first_name = object_data_input.read_utf()
self.last_name = object_data_input.read_utf()
self.salary = object_data_input.read_int()
self.company_name = object_data_input.read_utf()
def __str__(self):
return "Employee with Name: {}, LastName: {}, Salary: {}, CompanyName: {}".format(
self.first_name, self.last_name, self.salary, self.company_name)
if __name__ == "__main__":
config = hazelcast.ClientConfig()
# Register the custom Employee class to SerializationConfig.
factory = {Employee.CLASS_ID: Employee}
config.serialization_config.add_data_serializable_factory(
Employee.FACTORY_ID, factory)
client = hazelcast.HazelcastClient(config)
my_map = client.get_map("map")
keys = my_map.key_set().result()
for key in keys:
print("{} -> {}".format(key, my_map.get(key).result()))
client.shutdown()
def do_benchmark():
PROCESS_COUNT = 10
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
try:
from tests.hzrc.client import HzRemoteController
rc = HzRemoteController('127.0.0.1', '9701')
if not rc.ping():
logger.info("Remote Controller Server not running... exiting.")
exit()
logger.info("Remote Controller Server OK...")
rc_cluster = rc.createCluster(None, None)
rc_member = rc.startMember(rc_cluster.id)
config.network.addresses.append('{}:{}'.format(rc_member.host,
rc_member.port))
except (ImportError, NameError):
config.network.addresses.append('127.0.0.1')
client = hazelcast.HazelcastClient(config)
class ClientProcess(multiprocessing.Process):
def __init__(self, name, config, counts):
multiprocessing.Process.__init__(self, name=name)
self.counts = counts
self.config = config
self.daemon = True
def run(self):
client = hazelcast.HazelcastClient(config)
my_map = client.get_map("default")
while True:
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key)
self.counts[0] += 1
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key, "x" * VALUE_SIZE)
self.counts[1] += 1
else:
my_map.remove(key)
self.counts[2] += 1
processes = [
ClientProcess("client-process-%d" % i, config,
multiprocessing.Array('i', 3))
for i in range(0, PROCESS_COUNT)
]
for p in processes:
p.start()
start = time.time()
counter = 1
while counter < 1000:
time.sleep(5)
six.print_("ops per second : " + \
str(sum([sum(p.counts) for p in processes]) // (time.time() - start)))
# for p in processes:
# print ("%s: put: %d get: %d: remove: %d" % (p.name, p.counts[0], p.counts[1], p.counts[2]))
counter += 1
def do_benchmark():
REQ_COUNT = 50000
ENTRY_COUNT = 10 * 1000
VALUE_SIZE = 10000
GET_PERCENTAGE = 40
PUT_PERCENTAGE = 40
logging.basicConfig(
format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s',
datefmt="%H:%M%:%S,")
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger("main")
config = hazelcast.ClientConfig()
config.group_config.name = "dev"
config.group_config.password = "******"
try:
from hzrc.client import HzRemoteController
rc = HzRemoteController('127.0.0.1', '9701')
if not rc.ping():
logger.info("Remote Controller Server not running... exiting.")
exit()
logger.info("Remote Controller Server OK...")
rc_cluster = rc.createCluster(None, None)
rc_member = rc.startMember(rc_cluster.id)
config.network_config.addresses.append('{}:{}'.format(
rc_member.host, rc_member.port))
except (ImportError, NameError):
config.network_config.addresses.append('127.0.0.1')
client = hazelcast.HazelcastClient(config)
class Test(object):
def __init__(self):
self.ops = 0
self.event = threading.Event()
def incr(self, _):
self.ops += 1
if self.ops == REQ_COUNT:
self.event.set()
def run(self):
my_map = client.get_map("default")
for _ in xrange(0, REQ_COUNT):
key = int(random.random() * ENTRY_COUNT)
operation = int(random.random() * 100)
if operation < GET_PERCENTAGE:
my_map.get(key).add_done_callback(self.incr)
elif operation < GET_PERCENTAGE + PUT_PERCENTAGE:
my_map.put(key,
"x" * VALUE_SIZE).add_done_callback(self.incr)
else:
my_map.remove(key).add_done_callback(self.incr)
t = Test()
start = time.time()
t.run()
t.event.wait()
time_taken = time.time() - start
print("Took %s seconds for %d requests" % (time_taken, REQ_COUNT))
print("ops per second: %s" % (t.ops / time_taken))
from flask import request, Flask
import hazelcast
app = Flask(__name__)
client = hazelcast.HazelcastClient(cluster_name="dev",
cluster_members=[
"127.0.0.1:5703",
"127.0.0.1:5704",
"127.0.0.1:5705",
],
lifecycle_listeners=[
lambda state: print("State:", state),
])
distributed_map = client.get_map("map")
@app.route('/logging-service', methods=['GET', 'POST'])
def log_service():
if request.method == 'POST':
return proc_post_request()
else:
return ','.join([msg for msg in distributed_map.values().result()])
def proc_post_request():
print(f'RECEIVED request: {request}')
uuid = request.json["uuid"]
msg = request.json["msg"]
print("uuid: " + uuid + " " + "msg: " + msg)
distributed_map.put(uuid, msg)
print(f'SAVED to messages')
import hazelcast
# Connect
client = hazelcast.HazelcastClient(cluster_members=["127.0.0.1:5701"])
# We can access maps on the server from the client. Let's access the greetings map that we created already
greetings_map = client.get_map("greetings-map").blocking()
# Get the entry set of the map
entry_set = greetings_map.entry_set()
# Print key-value pairs
for key, value in entry_set:
print("%s -> %s" % (key, value))
# Shutdown the client
client.shutdown()
import hazelcast
# Client will try to connect to the cluster using the provided
# public address and it will connect to the other cluster members
# using their public addresses, if available.
client = hazelcast.HazelcastClient(
cluster_members=["myserver.publicaddress.com:5701"],
use_public_ip=True,
)
m = client.get_map("my-map").blocking()
m.set(1, 100)
value = m.get(1)
print("Value for the key `1` is %s." % value)
client.shutdown()
