def removeServices(serviceid):
logging.info('Remove the service %s', serviceid)
try:
docker_client = docker.from_env()
docker_remove = docker_client.services.get(serviceid)
docker_remove.remove()
remove_ser = models.Service.query.all()
for i in remove_ser:
if (i.serviceid == serviceid):
db.session.delete(i)
db.session.commit()
break
except docker.errors.APIError as e:
if e.status_code == 404:
remove_ser = models.Service.query.all()
for i in remove_ser:
if (i.serviceid == serviceid):
db.session.delete(i)
db.session.commit()
break
else:
logging.error('Unable to remove the service %s. \nReason: %s', serviceid, str(e))
python类db()的实例源码
def deleteImage(image_name):
logging.info('Delete the image %s', image_name)
try:
docker_client = docker.from_env()
registry_imagename = registry + '/' + image_name
docker_client.images.remove(image=registry_imagename,force=True)
image = models.Image.query.filter_by(imagename=image_name).first()
db.session.delete(image)
db.session.commit()
except docker.errors.APIError as e:
image = models.Image.query.filter_by(imagename = image_name).first()
db.session.delete(image)
db.session.commit()
error_string = 'Unable to delete the image {}. \nReason: {}. Delete the record'.format(registry_imagename, str(e))
logging.error(error_string)
return error_string
return None
def signup():
from forms import SignupForm
form = SignupForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data.lower()).first()
if user is not None:
form.email.errors.append("The Email address is already taken.")
return render_template('signup.html', form=form)
newuser = User(form.firstname.data,form.lastname.data,form.email.data,form.password.data)
db.session.add(newuser)
db.session.commit()
session['email'] = newuser.email
return redirect(url_for('login'))
return render_template('signup.html', form=form)
def ping(service_id):
from app import db, models
from models import Service
finding = Service.query.filter_by(serviceid=service_id).first()
if finding is not None:
image_name = finding.imagename
uploadn = finding.uploadname
usern = finding.username
firstcreatetime = finding.firstcreatetime
u = Service(serviceid = service_id, createdtime = str(time.time()), imagename = image_name, uploadname = uploadn, username = usern, firstcreatetime = firstcreatetime)
db.session.add(u)
db.session.commit()
db.session.delete(finding)
db.session.commit()
else:
return "The service "+service_id+" has been removed!"
return "There are existing service:"+service_id
def put(self):
"""Change the password"""
us = User.query \
.filter(User.disabled == 0) \
.filter(User.id_user == g.current_user) \
.first()
abort_if_none(us, 404, 'User not found')
if not check_password_hash(us.password, request.json['old_password']):
return msg('Old password incorrect'), 403
us.password = request.json['password']
db.session.commit()
cache.blacklisted_tokens.append(request.headers['Authorization'])
return msg('success!')
def parse_update_optional_args(parser):
# just for updating lots
parser.add_argument('--limit', "-l", nargs="?", type=int, help="how many jobs to do")
parser.add_argument('--chunk', "-ch", nargs="?", default=10, type=int, help="how many to take off db at once")
parser.add_argument('--after', nargs="?", type=str, help="minimum id or id start, ie 0000-0001")
parser.add_argument('--rq', action="store_true", default=False, help="do jobs in this thread")
parser.add_argument('--order', action="store_true", default=True, help="order them")
parser.add_argument('--append', action="store_true", default=False, help="append, dont' clear queue")
parser.add_argument('--name', nargs="?", type=str, help="name for the thread")
# just for updating one
parser.add_argument('--id', nargs="?", type=str, help="id of the one thing you want to update")
parser.add_argument('--doi', nargs="?", type=str, help="doi of the one thing you want to update")
# parse and run
parsed_args = parser.parse_args()
return parsed_args
def run_update(parsed_args):
update = update_registry.get(parsed_args.fn)
start = time()
#convenience method for handling an doi
if parsed_args.doi:
from pub import Pub
from util import clean_doi
my_pub = db.session.query(Pub).filter(Pub.id==clean_doi(parsed_args.doi)).first()
parsed_args.id = my_pub.id
logger.info(u"Got database hit for this doi: {}".format(my_pub.id))
update.run(**vars(parsed_args))
db.session.remove()
logger.info(u"finished update in {} secconds".format(elapsed(start)))
def adduser():
"""add user"""
from getpass import getpass
username = raw_input("\_username: ")
email = raw_input("\_email: ")
role_id = raw_input("\_[1:moderator 2:admin 3:user]: ")
password = getpass("\_password: ")
u = User(
email = email,
username = username,
password = password,
role_id = role_id
)
db.session.add(u)
db.session.commit()
print "<user %s add in database>" % username
def adduser():
"""add user"""
from getpass import getpass
username = raw_input("\_username: ")
email = raw_input("\_email: ")
role_id = raw_input("\_[1:moderator 2:admin 3:user]: ")
password = getpass("\_password: ")
u = User(
email = email,
username = username,
password = password,
role_id = role_id
)
db.session.add(u)
db.session.commit()
print "<user %s add in database>" % username
def get_count():
comments = Comment.query.all()
for comment in comments:
for word in comment.parsed.split('/'):
if word in pos_list:
comment.pos_count += 1
elif word in neg_list:
comment.neg_count += 1
elif '80' <= word and word <= '99':
comment.pos_count += 1
elif '0' <= word and word < '80':
comment.neg_count += 1
db.session.add(comment)
print "Comment %04d counted!" % comment.id
db.session.commit()
print "ALL DONE!"
def adduser():
"""add user"""
from getpass import getpass
username = raw_input("\_username: ")
email = raw_input("\_email: ")
role_id = raw_input("\_[1:moderator 2:admin 3:user]: ")
password = getpass("\_password: ")
u = User(
email = email,
username = username,
password = password,
role_id = role_id
)
db.session.add(u)
db.session.commit()
print "<user %s add in database>" % username
def message():
if request.method == 'POST':
myid = request.get_json().get("myid")
#message list
conn = redis.StrictRedis(host='redis', port=6380, db=10)
prem = conn.get(myid)
if prem is not None:
messagelist = pickle.loads(prem)
if messagelist == []:
return jsonify({
"message":"none"
}), 200
else:
conn.set(myid,pickle.dumps([]))
return jsonify({"messages":messagelist}), 200
else:
return jsonify({"message":"notfound"}), 404
def make_shell_context():
return dict(app=app,
db=db,
User=User,
Organization=Organization,
Location=Location,
Role=Role,
Schedule2=Schedule2,
Shift2=Shift2,
RecurringShift=RecurringShift,
RoleToUser=RoleToUser,
Preference=Preference,
cache=cache,
SessionCache=SessionCache,
Timeclock=Timeclock,
TimeOffRequest=TimeOffRequest,
ApiKey=ApiKey)
def reset_password(self, user_id):
"""
This method reset password of user with specified email
and send notification email on it
"""
user = db.session.query(User).filter_by(id=user_id).first()
password = self.generate_password()
hashed_password = self.password_to_hash(password)
# print password, " --> ", hashed_password
user.password = hashed_password
# print "Trying to reset password of ", user.full_name
db.session.commit()
try:
send_reset_password_email(user, password)
return {'result': 'success'}, 200
except Exception, error:
print "EXCEPTION: ", error
traceback.print_exc()
return {'result': 'error'}, 404
def dashboard_service():
resp = flask.Response(json.dumps({'status': 'failed'}))
if request.method == 'GET':
result = {}
f = db.session.execute(db.session.query(func.count(Formulation.id))).first()
result['formulationNumber'] = f[0] if f[0] else 0
t = db.session.execute(db.session.query(func.count(Test.id))).first()
result['testNumber'] = t[0] if t[0] else 0
d = db.session.execute(db.session.query(func.count(TestData.id))).first()
result['dataNumber'] = d[0] if d[0] else 0
a = db.session.execute(db.session.query(func.count(TestAttachment.id))).first()
result['attachmentNumber'] = a[0] if a[0] else 0
result.update({'status': 'success'})
resp = flask.Response(json.dumps(result))
return set_debug_response_header(resp)
############################################################
# dashboard services end #
############################################################
############################################################
# tests services begin #
############################################################
def adduser():
"""add user"""
from getpass import getpass
username = raw_input("\_username: ")
email = raw_input("\_email: ")
role_id = raw_input("\_[1:moderator 2:admin 3:user]: ")
password = getpass("\_password: ")
u = User(
email = email,
username = username,
password = password,
role_id = role_id
)
db.session.add(u)
db.session.commit()
print ("<user %s add in database>") % username
# =======
# >>>>>>> ec2645b42e8d0b874bf3ca3e57dd7dd3e98d9fb0
def createsuperuser():
"""
Method for create super user
"""
data = _validuser()
user = models.User(
username=data['username'],
email=data['email'],
first_name=data['firstname'],
last_name=data['lastname'],
password=data['password'],
is_active=True,
is_admin=True
)
db.session.add(user)
db.session.commit()
print("SuperUser created!")
def createuser():
"""
Method for create user
"""
data = _validuser()
user = models.User(
username=data['username'],
email=data['email'],
first_name=data['firstname'],
last_name=data['lastname'],
password=data['password'],
is_active=True,
is_admin=False
)
db.session.add(user)
db.session.commit()
print("User created!")
# Managers commands
def adduser():
"""add user"""
from getpass import getpass
username = raw_input("\_username: ")
email = raw_input("\_email: ")
role_id = raw_input("\_[1:moderator 2:admin 3:user]: ")
password = getpass("\_password: ")
u = User(
email = email,
username = username,
password = password,
role_id = role_id
)
db.session.add(u)
db.session.commit()
print "<user %s add in database>" % username
def run_update(parsed_args):
update = update_registry.get(parsed_args.fn)
start = time()
#convenience method for handling an doi
if parsed_args.doi:
from models.doi import Publication
my_pub = db.session.query(Publication).filter(Publication.doi==parsed_args.doi).first()
parsed_args.id = my_pub.id
print u"Got database for this doi: {}".format(my_pub.id)
update.run(
use_rq=parsed_args.rq,
obj_id=parsed_args.id, # is empty unless updating just one row
min_id=parsed_args.after, # is empty unless minimum id
num_jobs=parsed_args.limit,
chunk_size=parsed_args.chunk
)
db.session.remove()
print "finished update in {}sec".format(elapsed(start))
def index():
# Grab the choice variable passed from POST
# for x in request.args['choice']:
# print('in args: {}'.format(x))
# hook up database functions
Session = sessionmaker()
# locate the db location; currently hardcoded to development database
engine = create_engine('sqlite:///' + os.path.join(basedir, 'data-dev.sqlite'))
Session.configure(bind=engine)
session = Session()
post_count = session.query(func.count(Post.id)).scalar() # count number of unique posts in the table
pic1 = Post.query.get(randint(1, post_count)) # fails if there is 1 or less entries in the database
pic2 = None
while pic2 == pic1 or pic2 is None: # Don't pick the same file
pic2 = Post.query.get(randint(1, post_count))
pic1_filename = url_for('static', filename=pic1.filename)
pic2_filename = url_for('static', filename=pic2.filename)
return render_template('index.html', pic1=pic1, pic2=pic2, pic1_filename=pic1_filename, pic2_filename=pic2_filename)
def api_get_all(collection):
'''
get all documents from a collection
'''
if collection not in APIS:
abort(400)
cursor = db[collection]
a = []
for document in cursor.find().sort("created", -1):
if collection == 'users':
document.update(password='******')
document.update(_id=str(document['_id']))
a.append(document)
return jsonify({collection:a})
def api_edit_blog(blog_id):
'''
edit a blog and post it
'''
if not g.__user__.get('admin'):
return make_response('Permission denied.', 403)
title = request.form.get('title')
tag = request.form.get('tag').lstrip(r'/\;,. ').rstrip(r'/\;,. ')
content = request.form.get('content')
content = content.lstrip('\n').rstrip()
db.blogs.update_one(
{'_id': ObjectId(blog_id)},
{
'$set': {
'title': title.strip(),
'tag': re.split(r'[\s\;\,\.\\\/]+', tag),
'content': content,
'summary': '%s%s' % (content[:140], '...'),
'last_modified': True,
'modified': int(time.time())
}
})
return jsonify(blog_id=blog_id)
def api_delete_one(collection, item_id):
'''
delete one document from a certain collection
'''
if not g.__user__.get('admin'):
return make_response('Permission denied.', 403)
if collection == 'comments':
blog_id = db.comments.find_one({'_id': ObjectId(item_id)}).get('blog_id')
db[collection].delete_one({'_id': ObjectId(item_id)})
if collection == 'blogs':
db.comments.delete_many({'blog_id': ObjectId(item_id)})
if collection == 'comments':
return redirect(url_for('api.api_get_blog_comments', blog_id=blog_id))
return jsonify(item_id=item_id)
def api_delete_subcomment(comment_id, own_id):
'''
delete a subcomment from a certain comment
'''
if not g.__user__.get('admin'):
return make_response('Permission denied.', 403)
db.comments.update_one(
{'_id': ObjectId(comment_id)},
{
'$pull': {'subcontent': {'_id': own_id}}
})
if not db.comments.find_one({'_id': ObjectId(comment_id)}).get('subcontent'):
db.comments.update_one(
{'_id': ObjectId(comment_id)},
{
'$set': {'subcomment': False}
})
blog_id = db.comments.find_one({'_id': ObjectId(comment_id)}).get('blog_id')
return redirect(url_for('api.api_get_blog_comments', blog_id=blog_id))
def make_shell_context():
return dict(app=app, db=db,users=users,backhosts=backhosts,customers=customers,backarchives=backarchives,config=config)
def make_shell_context():
return dict(app = app, db = db, Article = Article, User = User, Site = Site, Packet = Packet)
def getServicePort(image_name):
logging.info('Starting a new services with image %s', image_name)
try:
image = registry+'/'+image_name
com_cre_ser = 'docker service create --replicas 1 --publish ' + ':9090 ' + image
service_ps = os.popen(com_cre_ser).read().split('\n')
service_id = service_ps[0]
time.sleep(5)
ser_ins = "docker service inspect " + service_id
ser_ins_ = json.loads(os.popen(ser_ins).read())
port=ser_ins_[0]["Endpoint"]["Ports"][0]["PublishedPort"]
get_node = models.ServerIP.query.first()
ip = get_node.serverip
except Exception, e:
logging.error('Unable to create the service with image %s. \nReason: %s', image_name, str(e))
return
logging.info('Store the service infomation to the db')
try:
imageinfo = models.Image.query.filter_by(imagename = image_name).first()
uploadn = imageinfo.uploadname
usern = imageinfo.uploaduser
service_record = Service(serviceid = service_id, createdtime = str(time.time()), imagename = image_name, uploadname = uploadn, username = usern, firstcreatetime = datetime.now())
db.session.add(service_record)
db.session.commit()
except Exception, e:
logging.error('Failed to store the service info to the db. \nReason: %s', str(e))
return
return ip+':'+str(port)+" "+service_id
def setting():
from app.forms import SetForm
form = SetForm()
if form.validate_on_submit():
servers = models.ServerIP.query.all()
for server in servers:
db.session.delete(server)
db.session.commit()
serverip = form.ip.data
u = models.ServerIP(serverip = serverip)
db.session.add(u)
db.session.commit()
return render_template('setting.html',form=form, succeed = True)
return render_template('setting.html',form=form)
def idetailed(image_name):
from app import db, models
image = models.Image.query.filter_by(imagename = image_name).first()
published_topics = StringToListOfDict(image.published_topics)
subscribed_topics = StringToListOfDict(image.subscribed_topics)
pub_topic_list = []
sub_topic_list = []
for pub_topic in published_topics:
pub_topic_list.append(pub_topic.get("topic_name"))
for sub_topic in subscribed_topics:
sub_topic_list.append(sub_topic.get("topic_name"))
return render_template('idetailed.html',imagename = image.imagename, uploadname = image.uploadname, uploaduser = image.uploaduser, uploadtime = image.uploadtime, subscribed_topics = sub_topic_list, published_topics = pub_topic_list, advertised_services = StringToList(image.advertised_services), advertised_actions = StringToList(image.advertised_actions), comments = image.comments)
