Professor Komla Tsey is Tropical Leader and Research Professor in Education for Social Sustainability within the School and The Cairns Institute. He is a highly qualified research professor with more than 25 years experience who provides leadership as part of transdisciplinary teams across the School of Education, The Cairns Institute and beyond to; undertake developmental research in the field of education for social sustainability; build a longer-term education for social sustainability collaborative research agenda; and mentor and support emerging researchers to become independent competitive researchers.
Professor Tsey is passionately committed to the ethical conduct of research, and to ensuring that research that he leads demonstrates tangible benefits for the research participants.
Professor Tsey was Head of the Central Australian Unit Menzies School of Health Research (1995-99) and contributed significantly towards the setting up of Cooperative Research Centre for Aboriginal Health (now Lowitja Institute) and was one of the CRC's 5 inaugural Research Program Leaders. Over the past decade, Komla has led a research team at JCU and The University of Queensland to operationalise and build research evidence-base for Aboriginal-developed community empowerment programs.
He is an expert in leading diverse research programs into politically sensitive and contemporary health, education, welfare and other social issues concerning Australia's Indigenous and rural Ghanaian communities and beyond. He utilises original and collaborative empowerment and participatory approaches to improving understanding of social circumstances and the relationship between these and government policies, thereby improving and sustaining health and wellbeing in population subsets.
A whole-of-community approach to promoting engagement into education in a discrete indigenous community: A mixed method study. An ARC Discovery Project.
Building a cohort of indigenous research leaders in community health development. An NH&MRC Capacity Building Grant with the University of South Australia.
Building research capacity in Indigenous Australians and community controlled services. An NH&MRC Capacity Building Grant with the School of Public Health, Tropical Medicine and Rehabilitation Sciences; Indigenous Health Unit; Australian Institute of Tropical Medicine; School of Medicine & Dentistry.
Swine influenza containment strategies: Feasible containment strategies for swine influenza H1N1 in rural and remote indigenous communities. An NH&MRC project with the School of Public Health, Tropical Medicine and Rehabilitation Sciences; School of Education.
Economic evaluation of interventions to reduce the burden of harm from alcohol misuse in Indigenous Australians. An NH&MRC project with the School of Indigenous Australian Studies; School of Education.
The feasibility and effectiveness of a family based intervention for Indigenous Australians. An NH&MRC project with the School of Education.
Palliative care for Aboriginal and Torres Strait Islander people with end-stage renal disease: An action research initiative. An NH&MRC project with School of Medicine; School of Indigenous Australian Studies.
Pandemic influenza containment strategies in Aboriginal communities: What is acceptable and feasible? An NH&MRC project with the School of Public Health, Tropical Medicine and Rehabilitation Sciences; School of Education.
Pearl in the oyster: Caring for country and building mental health resilience to adverse climate change in rural and remote Aboriginal communities. An NH&MRC project with the University of Canberra, CSIRO, ANU, School of Indigenous Australian Studies.
A structured systems approach for improving health promotion practice for chronic diseases in indigenous communities. An NH&MRC project with the Northern Territory Department of Health and Community Services (NTDHCS); Menzies School of Health Research (MSHR); CRC for Aboriginal Health (CRCAH).
Tropical, Rural and Indigenous Communicable Disease Control (TRICDC). An NH&MRC project with the School of Public Health, Tropical Medicine and Rehabilitation Sciences; School of Education.
Strategies designed to promote the longer term sustainability of the Empowerment Research Program. A Department of Education, Employment & Workplace Relations - Research Infrastructure Block Grant with the School of Education; School of Indigenous Australian Studies.
Sexual health management in NPA & TSI with the delivery of the Family Wellbeing Program. A Queensland Health – Consultancy with the School of Education; Tropical Population Health Unit, Queensland Health; Cooperative Research Centre for Aboriginal Health. Preparedness of schools for climate change contingencies. A JCU Collaboration Across Boundaries Grant with the School of Education, Public Health and Tropical Medicine, Nursing, Midwifery and Nutrition.
Making a difference: Promoting sustainable change in education, training and employment in Yarrabah. Indigenous Coordinating Council, Yarrabah Aboriginal Shire Council, Education Queensland. Project with the School of Education.
Making a difference: Planning for improved emotional and social wellbeing for Yarrabah. A Gurriny Yealamucka Health Service - Collaborative Research Project with the School of Education.
Preparedness of schools for climate change contingencies. A JCU Collaboration Across Boundaries Grant with the School of Education, Public Health and Tropical Medicine, Nursing, Midwifery and Nutrition.
Social Inclusion, Empowerment and Participation Network of the World Health Organisation Commission on the Social Determinants of Health.
Heyeres M, Kinchin I, Whatley E, Brophy L, Jago J, Wintzloff T, Morton T, Mosby V, Gopalkrishnan N and Tsey K (2018) Evaluation of a residential mental health recovery service in north Queensland. Frontiers in Public Health, 6.
McCalman J, Bailie R, Bainbridge R, McPhail-Bell K, Percival N, Askew D, Fagan R and Tsey K (2018) Continuous quality improvement and comprehensive primary healthcare: a systems framework to improve service quality and health outcomes. Frontiers in Public Health, 6.
McCalman J, Bainbridge R, Brown C, Tsey K and Clarke A (2018) The Aboriginal Australian family wellbeing program: a historical analysis of the conditions that enabled its spread. Frontiers in Public Health, 6.
Onnis L, Hakendorf M and Tsey K (2018) How are continuous quality improvement (CQI) approaches used in evaluating management development programs? a literature review. Asia Pacific Journal of Health Management, 13 (2).
ResearchOnline@JCU stores 168+ research outputs authored by Prof Komla Tsey from 1994 onwards.
This study seeks to understand the prevalence, perceptions and motivations of cyberbullying among adolescents as well as the coping behaviours, mental and emotional well-being of adolescent victims of cyberbullying among Singapore youths aged 10-16 years old. This study will also inform the design of research-based cyber wellness prevention and intervention programmes.
The remote management program uses a CQI approach to developing, implementing and evaluating participant satisfaction, but does not evaluate impact beyond the program-level. An evaluation suggests that there may be benefit in additional customised versions for areas of identified need (e.g. Indigenous remote managers), and that evaluation of the CQI approach and the program?s impact for health services and remote populations is warranted. The small group size of these types of programs makes it difficult to provide conclusive evidence about the impact; hence, this project investigates the feasibility of a research design investigating evidence beyond the usual limitations.
To date CRE-IQI research has focused on the application of quality improvement in the context of clinical and other services and programs delivered mainly through primary health care centres. Extending the quality improvement knowledge base beyond the scope of health services is an objective of the CRE-IQI. The current project will develop and implement partnership models that can support quality improvement implementation across the broader social, emotional cultural and other determinants of health and wellbeing.
The proposed project will bring together researchers and Indigenous community members to develop a collaborative framework for measuring research benefit. It will address two main 'Closing the Gap' priority areas, Indigenous health and education, by questioning what constitutes research benefit from an Indigenous perspective, and how can the benefits of research be measured to ensure sustainable outcomes for Indigenous communities. The innovation of this project lies in its methodology which will unpack the benefit construct from an Indigenous worldview to enable future research projects to be designed with outcomes in mind that are acceptable and valued by Indigenous beneficiaries and be informed by Indigenous knowledge.
Responsive to concerns of suicide risk for transitioning students by Education Queensland's Transition Support Service, this study will examine the implementation and effectiveness (including cost-effectiveness) of a targeted mentoring approach that promotes psychosocial resilience against suicide for remote Indigenous students who are compelled to transition to boarding schools. It will contribute practice - and policy-relevant knowledge for education providers and broader Indigenous suicide prevention efforts.
This study will describe and theorise the understanding of stillbirth and experiences of providing care to women following stillbirth with a cohort of midwifery students at a university in Papua New Guinea. The study will document social, cultural, spiritual and professional factors that inform the provision of care fro the perspective of midwifery students who have been maternal healthcare providers prior to enrolment. The study will contribute to the body of knowledge on stillbirth experiences in resources limited and complex social and cultural settings, and enhance collaboration between JCU and Pacific Adventist University.
ABCD Case Studies Project: Quality improvement in Aboriginal primary health care: lessons from the best to better the rest.
High performing primary health care (PHC) services are essential to "close the gap" in Aboriginal and Torres Strait Islander health outcomes. Little previous research has investigated the contextual factors around a particular service that influence the success of quality improvement initiatives. We aim to transfer knowledge about the processes that facilitate the success of quality improvement initiatives in these services whilst building research and evaluation capacity in the services.
Resilience, the capacity to negotiate and shape environments in which people can respond to life?s challenges in healthy meaningful ways, is key to flourishing in life. But there is an absence of evidence about how pathways to resilience are navigated by culturally diverse populations. With a specific focus on the cultural determinants, this research will explain how pathways to resilience are negotiated by Aboriginal and Torres Strait Islander adolescents to sustain their health and wellbeing.
How midwifery students at a university in PNG understand, experience and manage the provision of care to women following stillbirth.
This study will describe and theorise the understanding of stillbirth and experiences of providing care to women following stillbirth with a cohort of midwifery students at a univeristy in Papua New Guinea. The study will document social, cultural, spiritual and professional factors that inform the provision of care from the perspective of midwifery students who have been maternal healthcare providers prior to enrolment. The study will contribute to the body of knowledge on stillbirth experiences in resource limited and complex social and cultural settings, and enhance collaboration between JCU and Pacific Adventist University.
The Apunipima and JCU partnership proposes to systematically review the literature to answer three overarching research questions: 1) What family-centred approaches have been documented to improve MCH and what are their effectiveness? 2) What indicators are used to measure the effects of family-centred MCH approaches? 3) To what extend have their costs and benefits been documented?


text:
Johan Sylvius, född 10 juni 1620 i Karlstad, död 2 augusti 1690, var en svensk lagman och häradshövding.

Han var hertig Carl Gustafs sekreterare 1653 och blev assessor i Svea hovrätt 1654. Häradshövding i Tio häraders domsaga 1655. Han var lagman i Värmlands lagsaga från 1685 till sin död 1690. Adlad 1653.

Referenser
Sylvius nr 602 tab 1 på Adelsvapen

Noter

Män
Födda 1620
Avlidna 1690
Lagmän i Värmland
Svenska häradshövdingar

redpajama_set_name: RedPajamaWikipedia


LOS ANGELES, April 16, 2019 /PRNewswire/ -- MSBAI today announced the launch of an equity crowdfunding campaign on StartEngine (startengine.com/msbai) raising $107,000 to commercialize the GURU Engineering Artificial Intelligence Assistant.
The United States is a world leader in supercomputing, but most product developers and manufacturers don't use it because it's too complicated1. The Department of Energy says that despite the great potential of advanced engineering tools and High Performance Computing, it remains underutilized2. NASA said the solution must minimize user intervention and full automation is essential3. High Performance Computing used to only be available to a small number of specialists at government facilities — or the largest companies with highest budgets. Today cloud computing is available via internet from companies like AWS, Google, IBM, Microsoft, and Rescale. But a large percentage of companies still aren't using it, which impacts their competitiveness and has harmed the economy.
Imagine you had an Artificial Intelligence Assistant that could make it easy for you — enabling you to perform these complex tasks even though you don't have the training. That's what we're doing with GURU. We call it GURU because you don't need to be the guru — you focus on your design, and we put your engineering on ludicrous mode.
Product designers and manufacturers who use High Performance Computing get 500 dollars back in increased revenue from every dollar they spend on it1. GURU will enable all these new entrants into this 50 billion dollar market, and the market size is projected to subsequently double in three to five years.
Erik Franks, CEO of Tesseract Space Inc., said, "We're looking forward to getting a lot more done in engineering as a GURU customer!"
"We've seen the need from both the vendor and the customer side, and we know GURU will empower a lot of companies to become much more competitive," said MSBAI CEO Allan Grosvenor.


What is average salary for Architect Constructions in Nairobi, Kenya?
Based on our survey (15 individual salary profiles) average GROSS salary for Architect Constructions in Nairobi, Kenya is KES 2,052,666. Average NET salary is KES 1,620,826. The most frequent GROSS salary is KES 1,326,000. The most frequent education is Bachelors Degree. The most frequent experience are 4-8 Years.
Bachelors Degree, 0-1 year: "i am a graduate architect from the University of Nairobi with 1St Class Honors."
Bachelors Degree, 0-1 year: "we take time to design buildings by surveying, sketching, project design and finally the actual building"
Bachelors Degree, 0-1 year: "we help refine house interiors with our own art designs and sell the ideas.."
Bachelors Degree, 4-8 years: "Architectural design, dealing with survey design and implementation of construction projects."
Bachelors Degree, 4-8 years: "DESIGN, CONSTRUCTION SUPERVISION"
Bachelors Degree, 0-1 year: "Graduate architect, doing general work and accumulating experience before registration"


text:
CINEMA TIMES
Belfast Cinema Times
Dublin Cinema Times
Limerick Cinema Times
Galway Cinema Times
Cork Cinema Times
2016 Homepage
Samuel L. Jackson to Star In Chris Rock's SAW Reboot
GEORGE R.R. MARTIN to visit IFI for a special screening of FORBIDDEN PLANET
Netflix Planning SANDMAN Series With Neil Gaiman and David Goyer
ONCE UPON A TIME IN HOLLYWOOD Images Offer New Look at Quentin Tarantino's 9th Movie
Animated GREMLINS Prequel Series Gets Greenlight
Irish film A BUMP ALONG THE WAY gets August release date
3.0Warmly reverent
3.0Best of the bunch
4.5Fabulous & freaky
3.5Enjoyable webspinner
3.0Noble salute
The Cold Blue
3.5Beats strongly
COMPETITION - Win tickets to a preview of METAL HEART
COMPETITION - Win exclusive BOOKSMART movie prizes
COMPETITION : Win tickets to the premiere of GODZILLA : KING OF THE MONSTERS
COMPETITION - Win tickets to a preview of LATE NIGHT
COMPETITION : Win tickets to a preview of ALADDIN
COMPETITION - Win prizes from THE CURSE OF LA LLORONA
METAL HEART - Interview with Irish director Hugh O'Conor
Video - Tom Hanks & Tim Allen chat about TOY STORY 4
Interview - WESTLIFE talk about their live cinema debut
PAPI CHULO - Interview with Irish director John Butler
Aladdin interview - Navid Negahban talks about playing Sultan
ROCKETMAN Interview - Taron Egerton talks about playing Elton John
ANNABELLE COMES HOME - Warren's Daughter Feature
Sacha Gervasi To Direct Boy George Biopic
Godzilla : King Of The Monsters - Know Your Titans
Beloved Movie Pets – From 'Inside Llewyn Davis' to 'Marley & Me' to 'The Secret Life Of Pets 2'
ROCKETMAN Feature : A Look At The Costumes Of The Musical Fantasy
Pets walk the red carpet at Irish premiere of THE SECRET LIFE OF PETS 2
Watch: New Trailer for Irish Supernatural Comedy EXTRA ORDINARY
Renée Zellweger Shines As Judy Garland In Latest JUDY Trailer
DORA AND THE LOST CITY OF GOLD Trailer Features Swiper the Fox and Boots
Watch: Wicked New Trailer for MALEFICENT: MISTRESS OF EVIL Released
Will Smith Is The World's Flyest Spy in SPIES IN DISGUISE Trailer
Trailer: Joel Kinnaman Goes Undercover in THE INFORMER
Tagged Billy O'Brien
I AM NOT A SERIAL KILLER – Interview with director Billy O'Brien & Actor Max Records.
The Most Unsettling & Unpredictable Movie Of The Year! Go behind the scenes of I AM NOT A SERIAL KILLER with Max Records and Irish director Billy O'Brian. Watch our interview with them below. Movie Summ...
Trailer for Irish Writer/Director Billy O'Brien's I AM NOT A SERIAL KILLER
"You don't know the things I've done, or that I will do." In Irish cinemas December 9th, Irish writer/director Billy O'Brien's I AM NOT A SERIAL KILLER is a dazzlingly original, darkly funny and disturbing ...
I AM NOT A SERIAL KILLER – Trailer for ISOLATION Helmer's Latest
'Every Town Has Its Monster' The new film from Irish filmmaker Billy O'Brien, I AM NOT A SERIAL KILLER follows John Wayne Cleaver, a 15-year-old (Max Records) with homicidal tendencies who must hunt down and destroy a supernatural killer whilst keeping his...
MORE ARTICLES TO CHECK OUT
"Why does it have to be so unnecessarily gross?" Official trailer for writer/directors Mike Ahern and Enda Loughman's su...
Pavarotti (UK / USA / 12A / 114 mins) In short: Warmly reverent Directed by Ron Howard. Starring Luciano Pavarot...
Samuel L. Jackson to Star In Chris Rock's SAW Reboot
Samuel L. Jackson is set to join Chris Rock for Lionsgate and Twisted Pictures' upcoming reboot of horror franchise 'Saw...
Winter 1968 and showbiz legend Judy Garland arrives in Swinging London to perform in a sell-out run at The Talk of the...
4.0Agreeable confection
Movies.ie – Older Articles
Movies.ie – Older Articles Select Month July 2019 June 2019 May 2019 April 2019 March 2019 February 2019 January 2019 December 2018 November 2018 October 2018 September 2018 August 2018 July 2018 June 2018 May 2018 April 2018 March 2018 February 2018 January 2018 December 2017 November 2017 October 2017 September 2017 August 2017 July 2017 June 2017 May 2017 April 2017 March 2017 February 2017 January 2017 December 2016 November 2016 October 2016 September 2016 August 2016 July 2016 June 2016 May 2016 April 2016 March 2016 February 2016 January 2016 December 2015 November 2015 October 2015 September 2015 August 2015 July 2015 June 2015 May 2015 April 2015 March 2015 February 2015 January 2015 December 2014 November 2014 October 2014 September 2014 August 2014 July 2014 June 2014 May 2014 April 2014 March 2014 February 2014 January 2014 December 2013 November 2013 October 2013 September 2013 August 2013 July 2013 June 2013 May 2013 April 2013 March 2013 February 2013 January 2013 December 2012 November 2012 October 2012 September 2012 August 2012 July 2012 June 2012 May 2012 April 2012 March 2012 February 2012 January 2012 December 2011 November 2011 October 2011 September 2011 August 2011 July 2011 June 2011 May 2011 April 2011 March 2011 February 2011 January 2011 December 2010 November 2010 October 2010 September 2010 August 2010 July 2010 June 2010 May 2010 April 2010 March 2010 February 2010 January 2010 December 2009 November 2009 October 2009 September 2009 August 2009 July 2009 June 2009 May 2009 April 2009 March 2009 February 2009 January 2009 December 2008 November 2008 October 2008 September 2008 August 2008 July 2008 June 2008 May 2008 April 2008 March 2008 February 2008 January 2008 December 2007 November 2007 October 2007 September 2007 August 2007
Cineworld - Dublin Eye Cinema - Galway Gaiety Cinema Sligo Gate Multiplex Cork Movies @ Dundrum Movies @ Swords Omniplex - Mahon Point Cork Ormonde - Stillorgan UCI Swan Cinemas Rathmines Omniplex Limerick Cinema
Movies.ie Review Archive
Irish Movie Release Dates Popular Tags on Movies.ie Forum Privacy Policy

redpajama_set_name: RedPajamaCommonCrawl


Limassol, December 10, 2010 -- Moody's Investors Service has today downgraded by one notch the global local-currency (GLC) deposit ratings and standalone bank financial strength ratings (BFSRs) of five Pakistani banks: Allied Bank Ltd (ABL), Habib Bank Ltd (HBL), MCB Bank Ltd (MCB), National Bank of Pakistan Ltd (NBP) and United Bank Ltd (UBL).
At the same time, Moody's has affirmed the foreign-currency deposit ratings assigned to these banks at B3/Not Prime (Stable outlook). The foreign-currency deposit ratings remain constrained by Pakistan's B3 (Stable outlook) country ceiling for foreign-currency deposits. Please see a full list of the rating actions below.
Moody's notes that the rating downgrades are primarily driven by the Pakistani banks' growing exposure to (B3 rated) Pakistan government securities and government-related lending, as a consequence of limited private sector lending opportunities within the country's deteriorating macroeconomic conditions. Moody's estimates that as of end-June 2010, the rated Pakistani banks' total exposure to sovereign-related risk assets had reached 38% of their total assets, from 24% in 2008, representing a material exposure concentration and raising the banking system's susceptibility to event risk at the B3 sovereign level. While the financial fundamentals of Pakistani banks have shown relative resilience during adverse conditions in previous years, their inability to curb their rising overall exposure to the government sector highlights the limitations in depth and diversification of the country's banking system. Although Moody's considers Pakistani rated banks' capitalisation levels as currently adequate, the high, and growing, exposure concentration to the B3-rated sovereign -- in conjunction with the prevailing weak macroeconomic conditions -- could challenge solvency levels. Driven by these considerations, Moody's has narrowed the gap between the Pakistani banks' ratings and the government rating (B3/stable).
As a result of the heavy flooding in Pakistan earlier this year, Moody's expects low economic growth and subdued loan demand from the private sector to prevail, leading to a further rise in banks' sovereign-related exposures, primarily in the form of T-Bills. At the same time, the sovereign structural subsidy-related debt arrears, mainly in the utility and commodity sectors, are unlikely to be settled in the near term, and such arrears will continue to exert further pressure on the corporate sector and, as a result, on the Pakistani banking system's asset quality.
Despite these growing challenges, Moody's believes that certain factors continue to support Pakistani banks' ratings being positioned at a higher level than the government rating. In particular, the rated banks have minimal reliance on sensitive market-funding, and instead display stable customer deposit-funded profiles that have shown a degree of stability during previous shocks or crises that Pakistan has experienced. Furthermore, Moody's believes that the rated banks' overall financial fundamentals remain relatively good, with profitability and capitalisation sufficiently absorbing the increased credit and impairment costs of the past two years, as stressed by the deterioration in asset quality, stemming from the challenging macroeconomic conditions.
Moody's decision to maintain the negative outlook on the banks' standalone and long-term local-currency deposit ratings reflects the Pakistani banking sector's still growing exposure concentration to the sovereign, and on-going vulnerability to macroeconomic deterioration, which could negatively impact both the sovereign and the country's banking system.
-ABL's GLC deposit ratings have been downgraded by one notch to B1/Not Prime, from Ba3/Not Prime and its standalone BFSR to E+ (mapping to B1), from D-. The local currency deposit ratings carry a negative outlook.
-HBL's GLC deposit ratings have been downgraded by one notch to B1/Not Prime, from Ba3/Not Prime and its standalone BFSR to E+ (mapping to B1), from D-. The local currency deposit ratings carry a negative outlook.
-MCB's GLC deposit ratings have been downgraded by one notch to Ba3/Not Prime, from Ba2 / Not Prime and its standalone BFSR to D- (mapping to Ba3) from D. The ratings carry a negative outlook.
-NBP's GLC deposit ratings have been downgraded by one notch to Ba3/Not Prime, from Ba2/Not Prime and its standalone BFSR to D- (mapping to Ba3), from D. The ratings carry a negative outlook.
-UBL's GLC deposit ratings have been downgraded by one notch to B1/Not Prime, from Ba3/Not Prime and its standalone BFSR to E+ (mapping to B1), from D-. The local currency deposit ratings carry a negative outlook.
The principal methodologies used in this rating were "Bank Financial Strength Ratings: Global Methodology", published in February 2007, and "Incorporation of Joint-Default Analysis into Moody's Bank Ratings: A Refined Methodology", published in March 2007.
The last rating action for all Pakistani rated banks was implemented on 2 September 2010, when Moody's changed the outlook on their local currency deposit ratings and standalone ratings to negative, from stable.
Headquartered in Lahore, Pakistan, Allied Bank had total assets of USD4.8 billion as of the end of September 2010.
Headquartered in Karachi, Pakistan, Habib Bank had total assets of USD10.1 billion as of the end of September 2010.
Headquartered in Lahore, Pakistan, MCB Bank had total assets of USD6.3 billion as of the end of September 2010.
Headquartered in Karachi, Pakistan, National Bank of Pakistan had total assets of USD10.9 billion as of the end of September 2010.
Headquartered in Karachi, Pakistan, United Bank had total assets of USD7.6 billion as of the end of September 2010.
Information sources used to prepare the credit rating are the following: parties involved in the ratings, and public information.
Moody's Investors Service considers the quality of information available on the issuers or obligation satisfactory for the purposes of maintaining a credit rating.
The ratings for Habib Bank Ltd, National Bank of Pakistan and United Bank were initiated by Moody's Investors Service and were not requested by the issuers.
These rated entities participated in the credit rating process. The rated entities or their related third party, if any, provided the rating committee access to the books, records and other relevant internal documents of the rated entities.
The rating has been disclosed to the rated entities or its designated agents and issued with no amendment resulting from that disclosure.


6300 - 6 in. T5 fluorescent smaller scale tubes feature a matte white acrylic cylindrical diffuser for even illumination, with optional LED MR16 downlight. Material: seamless cylindrical acrylic diffuser, with internal aluminum socket/ballast housing. Size: 6 in. diameter; 2, 3, or 4 ft. lengths.


Very good tips to make money online! Google Sniper 3.0 is really good, thanks for information!
Hey Anton: Thanks for stopping by…don't forget to watch the Business From Make Money Online video. It's motivational!


We did hope that a new submission would be made to the SITA Trust to try and obtain a grant to get the lake cleaned out but for various reasons the City Council was not able to do this. At the end of 2015 the club set up a Facebook campaign to raise awareness of the issue and to obtain emails of support from park users and local residents. This was quite succesfull and resulted in a total of 43 suitable emails being recieved which were converted into a PDF document and passed on to the council for inclusion in the next bid, due to be submitted early in 2016. It is thought that one of the reasons we failed last time was that we were not able to demonstrate local support for the bid. The PDF document should address that point.
An unexpected result of the campaign was that a couple of local residents offered to assist the club in doing a bit of basic lake cleaning early in the new year (2016). This most welcome offer has been gladly accepted.
The growing success of the "Tyne and Wear 2 Day regatta" weekend continued in 2015 with a record 100 entries in the straight running events during this years event. This regatta is now the premier straight running regatta in the whole of the UK. The club was founded back in 1910 with straight running boats and I'm sure the original founding members would be pleased to see that 100 years later the sport is alive and well.
The club had another successfull charity regatta weekend raising a total of £167.95 for the RNLI.


What it promises: To unknot the body and put it in balance with the mind.
What is it like? The peaceful, light treatment room set into the corner of a busy gym (no candles, no scented oils) seems an unlikely setting in which to find a world-class massage, but David Marshall of Bodydoctor Fitness has a reputation for ferreting out brilliant practioners for his elite clientele (top actresses to top footballers) and Carlos Jalon has been his masseur of choice for 15 years. As massages go, this one is extraordinary, the ultimate treat after a tough workout. Carlos uses his feet as much as his hands in a style of bodywork he describes as "instinctive and flowing". I am encouraged to breathe deeply and sigh out stresses and strains, which seems remarkably hard work, as Carlos kneads and pummels and stretches. I left feeling terrific; easier within my skin, and de-stressed in mind as well as body.
Downside: My neck is so tense that I find lying on the floor with it turned to the side tricky; but Carlos sorts that out too.
Expert View: Combines deep massage of the body with lymphatic drainage, with the aim of releasing physical and mental blocks in the body and flushing out toxins. Jalon has trained in every style of massage from Ayurvedic to Swedish over the past 20 years, so knows his subject like few others. Brilliant for improving all-round wellbeing.
Call 020 7235 2211for an appointment.


The Best Blackbutt Flooring Business in Burleigh BC | Gold Coast Floor Sanding | 4.5 Average Floor Sander Review Ratings!
If you need Blackbutt Flooring service in Burleigh BC, we can help you. Email us today for more information.
products to give your place, in Burleigh BC a sensational finish . It will give your floor coverings another life .
Wooden flooring will be able to add significance to your premises to make your visitors gasp with envy .
We apply the most beneficial floor sanding equipment available today .
Furthermore , we certainly have stringent Health & Safety procedures , to keep both you and our professionals risk-free .
Our Blackbutt Flooring mastersalways keep their supplies well-maintained to eliminate destructing your floor in order to make sure that we invariably execute a quality job . We're serious about our small business , and we perform things effectively .
Absolutely no more carpet spots , great for rental homes . Further , solid wood floor coverings just the thing for using benefits to your residence . We complete whatever we say we are going to , read our web basedreview articles for confirmation .
We are service providers makes a specialty of Floor Sanding rather than developing . No mater which part of Burleigh BC you are in, we will give you a personal Blackbutt Flooring quote.
Wooden floors work longer as opposed to rug or carpet and vinyl .
Great for people who have hypersensitivity , facilitates decrease hay fever .
Our team of professionals is here to assist and advise you through the entire process, ensuring that your renovation project will proceed smoothly, staying on schedule and on budget. phone our office staff for any questions you have at 0401 094 013. Or if we are in Burleigh BC we may pop in and give you personal Blackbutt Flooring quote.


text:
from neutron_lib.api.definitions import external_net as extnet_apidef
from neutron_lib.api.definitions import multiprovidernet as mpnet_apidef
from neutron_lib.api.definitions import portbindings
from neutron_lib.api.definitions import provider_net as provider
from neutron_lib.api import validators
from neutron_lib import constants
from neutron_lib.db import api as db_api
from neutron_lib import exceptions as exc
from neutron_lib.exceptions import multiprovidernet as mpnet_exc
from neutron_lib.exceptions import placement as place_exc
from neutron_lib.exceptions import vlantransparent as vlan_exc
from neutron_lib.plugins.ml2 import api
from oslo_config import cfg
from oslo_log import log
from oslo_utils import excutils
import stevedore

from neutron._i18n import _
from neutron.conf.plugins.ml2 import config
from neutron.db import segments_db
from neutron.objects import ports
from neutron.plugins.ml2.common import exceptions as ml2_exc

LOG = log.getLogger(__name__)

MAX_BINDING_LEVELS = 10
config.register_ml2_plugin_opts()

class TypeManager(stevedore.named.NamedExtensionManager):
    """Manage network segment types using drivers."""

    def __init__(self):
        # Mapping from type name to DriverManager
        self.drivers = {}

        LOG.info("Configured type driver names: %s",
                 cfg.CONF.ml2.type_drivers)
        super(TypeManager, self).__init__('neutron.ml2.type_drivers',
                                          cfg.CONF.ml2.type_drivers,
                                          invoke_on_load=True)
        LOG.info("Loaded type driver names: %s", self.names())
        self._register_types()
        self._check_tenant_network_types(cfg.CONF.ml2.tenant_network_types)
        self._check_external_network_type(cfg.CONF.ml2.external_network_type)

    def _register_types(self):
        for ext in self:
            network_type = ext.obj.get_type()
            if network_type in self.drivers:
                LOG.error("Type driver '%(new_driver)s' ignored because"
                          " type driver '%(old_driver)s' is already"
                          " registered for type '%(type)s'",
                          {'new_driver': ext.name,
                           'old_driver': self.drivers[network_type].name,
                           'type': network_type})
            else:
                self.drivers[network_type] = ext
        LOG.info("Registered types: %s", self.drivers.keys())

    def _check_tenant_network_types(self, types):
        self.tenant_network_types = []
        for network_type in types:
            if network_type in self.drivers:
                self.tenant_network_types.append(network_type)
            else:
                LOG.error("No type driver for tenant network_type: %s. "
                          "Service terminated!", network_type)
                raise SystemExit(1)
        LOG.info("Tenant network_types: %s", self.tenant_network_types)

    def _check_external_network_type(self, ext_network_type):
        if ext_network_type and ext_network_type not in self.drivers:
            LOG.error("No type driver for external network_type: %s. "
                      "Service terminated!", ext_network_type)
            raise SystemExit(1)

    def _process_provider_segment(self, segment):
        (network_type, physical_network,
         segmentation_id) = (self._get_attribute(segment, attr)
                             for attr in provider.ATTRIBUTES)

        if validators.is_attr_set(network_type):
            segment = {api.NETWORK_TYPE: network_type,
                       api.PHYSICAL_NETWORK: physical_network,
                       api.SEGMENTATION_ID: segmentation_id}
            self.validate_provider_segment(segment)
            return segment

        msg = _("network_type required")
        raise exc.InvalidInput(error_message=msg)

    def _process_provider_create(self, network):
        if any(validators.is_attr_set(network.get(attr))
               for attr in provider.ATTRIBUTES):
            # Verify that multiprovider and provider attributes are not set
            # at the same time.
            if validators.is_attr_set(network.get(mpnet_apidef.SEGMENTS)):
                raise mpnet_exc.SegmentsSetInConjunctionWithProviders()
            segment = self._get_provider_segment(network)
            return [self._process_provider_segment(segment)]
        elif validators.is_attr_set(network.get(mpnet_apidef.SEGMENTS)):
            segments = [self._process_provider_segment(s)
                        for s in network[mpnet_apidef.SEGMENTS]]
            mpnet_apidef.check_duplicate_segments(
                segments, self.is_partial_segment)
            return segments

    def _match_segment(self, segment, filters):
        return all(not filters.get(attr) or segment.get(attr) in filters[attr]
                   for attr in provider.ATTRIBUTES)

    def _get_provider_segment(self, network):
        # TODO(manishg): Placeholder method
        # Code intended for operating on a provider segment should use
        # this method to extract the segment, even though currently the
        # segment attributes are part of the network dictionary. In the
        # future, network and segment information will be decoupled and
        # here we will do the job of extracting the segment information.
        return network

    def network_matches_filters(self, network, filters):
        if not filters:
            return True
        if any(validators.is_attr_set(network.get(attr))
               for attr in provider.ATTRIBUTES):
            segments = [self._get_provider_segment(network)]
        elif validators.is_attr_set(network.get(mpnet_apidef.SEGMENTS)):
            segments = self._get_attribute(network, mpnet_apidef.SEGMENTS)
        else:
            return True
        return any(self._match_segment(s, filters) for s in segments)

    def _get_attribute(self, attrs, key):
        value = attrs.get(key)
        if value is constants.ATTR_NOT_SPECIFIED:
            value = None
        return value

    def extend_network_dict_provider(self, context, network):
        # this method is left for backward compat even though it would be
        # easy to change the callers in tree to use the bulk function
        return self.extend_networks_dict_provider(context, [network])

    def extend_networks_dict_provider(self, context, networks):
        ids = [network['id'] for network in networks]
        net_segments = segments_db.get_networks_segments(context, ids)
        for network in networks:
            segments = net_segments[network['id']]
            self.extend_network_with_provider_segments(network, segments)

    def extend_network_with_provider_segments(self, network, segments):
        if not segments:
            LOG.debug("Network %s has no segments", network['id'])
            for attr in provider.ATTRIBUTES:
                network[attr] = None
        elif len(segments) > 1:
            network[mpnet_apidef.SEGMENTS] = [
                {provider.NETWORK_TYPE: segment[api.NETWORK_TYPE],
                 provider.PHYSICAL_NETWORK: segment[api.PHYSICAL_NETWORK],
                 provider.SEGMENTATION_ID: segment[api.SEGMENTATION_ID]}
                for segment in segments]
        else:
            segment = segments[0]
            network[provider.NETWORK_TYPE] = segment[api.NETWORK_TYPE]
            network[provider.PHYSICAL_NETWORK] = segment[
                api.PHYSICAL_NETWORK]
            network[provider.SEGMENTATION_ID] = segment[
                api.SEGMENTATION_ID]

    @staticmethod
    def pop_segments_from_network(network):
        multiple_segments = network.pop(mpnet_apidef.SEGMENTS, [])
        if multiple_segments:
            network_segments = multiple_segments
        else:
            network_segments = [
                {provider_key: network.pop(provider_key)
                 for provider_key in provider.ATTRIBUTES}]

        return (
            [{api.NETWORK_TYPE: network_segment[provider.NETWORK_TYPE],
              api.PHYSICAL_NETWORK: network_segment[provider.PHYSICAL_NETWORK],
              api.SEGMENTATION_ID: network_segment[provider.SEGMENTATION_ID]}
             for network_segment in network_segments])

    def initialize(self):
        for network_type, driver in self.drivers.items():
            LOG.info("Initializing driver for type '%s'", network_type)
            driver.obj.initialize()

    def initialize_network_segment_range_support(self):
        for network_type, driver in self.drivers.items():
            if network_type in constants.NETWORK_SEGMENT_RANGE_TYPES:
                LOG.info("Initializing driver network segment range support "
                         "for type '%s'", network_type)
                driver.obj.initialize_network_segment_range_support()

    def _add_network_segment(self, context, network_id, segment,
                             segment_index=0):
        segments_db.add_network_segment(
            context, network_id, segment, segment_index)

    def _update_network_segment(self, context, network_id, segmentation_id):
        segments_db.update_network_segment(
            context, network_id, segmentation_id)

    def create_network_segments(self, context, network, tenant_id):
        """Call type drivers to create network segments."""
        segments = self._process_provider_create(network)
        filters = {'project_id': tenant_id}
        with db_api.CONTEXT_WRITER.using(context):
            network_id = network['id']
            if segments:
                for segment_index, segment in enumerate(segments):
                    segment = self.reserve_provider_segment(
                        context, segment, filters=filters)
                    self._add_network_segment(context, network_id, segment,
                                              segment_index)
            elif (cfg.CONF.ml2.external_network_type and
                  self._get_attribute(network, extnet_apidef.EXTERNAL)):
                segment = self._allocate_ext_net_segment(
                    context, filters=filters)
                self._add_network_segment(context, network_id, segment)
            else:
                segment = self._allocate_tenant_net_segment(
                    context, filters=filters)
                self._add_network_segment(context, network_id, segment)

    def update_network_segment(self, context, network, net_data, segment):
        """Call type drivers to update a network segment.

        Update operation is currently only supported for VLAN type segments,
        and only the SEGMENTATION_ID field can be changed.
        """
        project_id = network['project_id']
        segmentation_id = net_data.get(provider.SEGMENTATION_ID)
        network_type = segment[api.NETWORK_TYPE]
        if network_type != constants.TYPE_VLAN:
            msg = (_('Only VLAN type networks can be updated.'))
            raise exc.InvalidInput(error_message=msg)
        if not segmentation_id:
            msg = (_('Only %s field can be updated in VLAN type networks') %
                   api.SEGMENTATION_ID)
            raise exc.InvalidInput(error_message=msg)

        new_segment = {api.NETWORK_TYPE: segment[api.NETWORK_TYPE],
                       api.PHYSICAL_NETWORK: segment[api.PHYSICAL_NETWORK],
                       api.SEGMENTATION_ID: segmentation_id}
        self.validate_provider_segment(new_segment)
        self.reserve_provider_segment(context, new_segment,
                                      filters={'project_id': project_id})
        self._update_network_segment(context, segment['id'], segmentation_id)
        self.release_network_segment(context, segment)

    def reserve_network_segment(self, context, segment_data):
        """Call type drivers to reserve a network segment."""
        # Validate the data of segment
        if not validators.is_attr_set(segment_data[api.NETWORK_TYPE]):
            msg = _("network_type required")
            raise exc.InvalidInput(error_message=msg)

        net_type = self._get_attribute(segment_data, api.NETWORK_TYPE)
        phys_net = self._get_attribute(segment_data, api.PHYSICAL_NETWORK)
        seg_id = self._get_attribute(segment_data, api.SEGMENTATION_ID)
        segment = {api.NETWORK_TYPE: net_type,
                   api.PHYSICAL_NETWORK: phys_net,
                   api.SEGMENTATION_ID: seg_id}

        self.validate_provider_segment(segment)

        # Reserve segment in type driver
        return self.reserve_provider_segment(context, segment)

    def is_partial_segment(self, segment):
        network_type = segment[api.NETWORK_TYPE]
        driver = self.drivers.get(network_type)
        if driver:
            return driver.obj.is_partial_segment(segment)
        else:
            msg = _("network_type value '%s' not supported") % network_type
            raise exc.InvalidInput(error_message=msg)

    def validate_provider_segment(self, segment):
        network_type = segment[api.NETWORK_TYPE]
        driver = self.drivers.get(network_type)
        if driver:
            driver.obj.validate_provider_segment(segment)
        else:
            msg = _("network_type value '%s' not supported") % network_type
            raise exc.InvalidInput(error_message=msg)

    def reserve_provider_segment(self, context, segment, filters=None):
        network_type = segment.get(api.NETWORK_TYPE)
        driver = self.drivers.get(network_type)
        if isinstance(driver.obj, api.TypeDriver):
            return driver.obj.reserve_provider_segment(context.session,
                                                       segment, filters)
        else:
            return driver.obj.reserve_provider_segment(context,
                                                       segment, filters)

    def _allocate_segment(self, context, network_type, filters=None):
        driver = self.drivers.get(network_type)
        if isinstance(driver.obj, api.TypeDriver):
            return driver.obj.allocate_tenant_segment(context.session, filters)
        else:
            return driver.obj.allocate_tenant_segment(context, filters)

    def _allocate_tenant_net_segment(self, context, filters=None):
        for network_type in self.tenant_network_types:
            segment = self._allocate_segment(context, network_type, filters)
            if segment:
                return segment
        raise exc.NoNetworkAvailable()

    def _allocate_ext_net_segment(self, context, filters=None):
        network_type = cfg.CONF.ml2.external_network_type
        segment = self._allocate_segment(context, network_type, filters)
        if segment:
            return segment
        raise exc.NoNetworkAvailable()

    def release_network_segments(self, context, network_id):
        segments = segments_db.get_network_segments(context, network_id,
                                                    filter_dynamic=None)

        for segment in segments:
            self.release_network_segment(context, segment)

    def release_network_segment(self, context, segment):
        network_type = segment.get(api.NETWORK_TYPE)
        driver = self.drivers.get(network_type)
        if driver:
            if isinstance(driver.obj, api.TypeDriver):
                driver.obj.release_segment(context.session, segment)
            else:
                driver.obj.release_segment(context, segment)
        else:
            LOG.error("Failed to release segment '%s' because "
                      "network type is not supported.", segment)

    @db_api.retry_if_session_inactive()
    def allocate_dynamic_segment(self, context, network_id, segment):
        """Allocate a dynamic segment using a partial or full segment dict."""
        dynamic_segment = segments_db.get_dynamic_segment(
            context, network_id, segment.get(api.PHYSICAL_NETWORK),
            segment.get(api.SEGMENTATION_ID))

        if dynamic_segment:
            return dynamic_segment

        with db_api.CONTEXT_WRITER.using(context):
            driver = self.drivers.get(segment.get(api.NETWORK_TYPE))
            if isinstance(driver.obj, api.TypeDriver):
                dynamic_segment = driver.obj.reserve_provider_segment(
                    context.session, segment)
            else:
                dynamic_segment = driver.obj.reserve_provider_segment(
                    context, segment)
            segments_db.add_network_segment(context, network_id,
                                            dynamic_segment,
                                            is_dynamic=True)
        return dynamic_segment

    @db_api.retry_if_session_inactive()
    def release_dynamic_segment(self, context, segment_id):
        """Delete a dynamic segment."""
        segment = segments_db.get_segment_by_id(context, segment_id)
        if segment:
            with db_api.CONTEXT_WRITER.using(context):
                driver = self.drivers.get(segment.get(api.NETWORK_TYPE))
                if driver:
                    if isinstance(driver.obj, api.TypeDriver):
                        driver.obj.release_segment(context.session, segment)
                    else:
                        driver.obj.release_segment(context, segment)
                    segments_db.delete_network_segment(context, segment_id)
                else:
                    LOG.error("Failed to release segment '%s' because "
                              "network type is not supported.", segment)
        else:
            LOG.debug("No segment found with id %(segment_id)s", segment_id)

    def update_network_segment_range_allocations(self, network_type):
        driver = self.drivers.get(network_type)
        driver.obj.update_network_segment_range_allocations()

    def network_type_supported(self, network_type):
        return bool(network_type in self.drivers)

class MechanismManager(stevedore.named.NamedExtensionManager):
    """Manage networking mechanisms using drivers."""

    def __init__(self):
        # Registered mechanism drivers, keyed by name.
        self.mech_drivers = {}
        # Ordered list of mechanism drivers, defining
        # the order in which the drivers are called.
        self.ordered_mech_drivers = []

        LOG.info("Configured mechanism driver names: %s",
                 cfg.CONF.ml2.mechanism_drivers)
        super(MechanismManager, self).__init__(
            'neutron.ml2.mechanism_drivers',
            cfg.CONF.ml2.mechanism_drivers,
            invoke_on_load=True,
            name_order=True,
            on_missing_entrypoints_callback=self._driver_not_found,
            on_load_failure_callback=self._driver_not_loaded
        )
        LOG.info("Loaded mechanism driver names: %s", self.names())
        self._register_mechanisms()
        self.host_filtering_supported = self.is_host_filtering_supported()
        if not self.host_filtering_supported:
            LOG.info("No mechanism drivers provide segment reachability "
                     "information for agent scheduling.")

    def _driver_not_found(self, names):
        msg = (_("The following mechanism drivers were not found: %s")
               % names)
        LOG.critical(msg)
        raise SystemExit(msg)

    def _driver_not_loaded(self, manager, entrypoint, exception):
        LOG.critical("The '%(entrypoint)s' entrypoint could not be"
                     " loaded for the following reason: '%(reason)s'.",
                     {'entrypoint': entrypoint,
                      'reason': exception})
        raise SystemExit(str(exception))

    def _register_mechanisms(self):
        """Register all mechanism drivers.

        This method should only be called once in the MechanismManager
        constructor.
        """
        for ext in self:
            self.mech_drivers[ext.name] = ext
            self.ordered_mech_drivers.append(ext)
        LOG.info("Registered mechanism drivers: %s",
                 [driver.name for driver in self.ordered_mech_drivers])

    def initialize(self):
        for driver in self.ordered_mech_drivers:
            LOG.info("Initializing mechanism driver '%s'", driver.name)
            driver.obj.initialize()

    def _check_vlan_transparency(self, context):
        """Helper method for checking vlan transparecncy support.

        :param context: context parameter to pass to each method call
        :raises: neutron_lib.exceptions.vlantransparent.
        VlanTransparencyDriverError if any mechanism driver doesn't
        support vlan transparency.
        """
        if context.current.get('vlan_transparent'):
            for driver in self.ordered_mech_drivers:
                if not driver.obj.check_vlan_transparency(context):
                    raise vlan_exc.VlanTransparencyDriverError()

    def _call_on_drivers(self, method_name, context,
                         continue_on_failure=False, raise_db_retriable=False):
        """Helper method for calling a method across all mechanism drivers.

        :param method_name: name of the method to call
        :param context: context parameter to pass to each method call
        :param continue_on_failure: whether or not to continue to call
        all mechanism drivers once one has raised an exception
        :param raise_db_retriable: whether or not to treat retriable db
        exception by mechanism drivers to propagate up to upper layer so
        that upper layer can handle it or error in ML2 player
        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver call fails. or DB retriable error when
        raise_db_retriable=False. See neutron_lib.db.api.is_retriable for
        what db exception is retriable
        """
        errors = []
        for driver in self.ordered_mech_drivers:
            try:
                getattr(driver.obj, method_name)(context)
            except Exception as e:
                if raise_db_retriable and db_api.is_retriable(e):
                    with excutils.save_and_reraise_exception():
                        LOG.debug("DB exception raised by Mechanism driver "
                                  "'%(name)s' in %(method)s",
                                  {'name': driver.name, 'method': method_name},
                                  exc_info=e)
                LOG.exception(
                    "Mechanism driver '%(name)s' failed in %(method)s",
                    {'name': driver.name, 'method': method_name}
                )
                errors.append(e)
                if not continue_on_failure:
                    break
        if errors:
            raise ml2_exc.MechanismDriverError(
                method=method_name,
                errors=errors
            )

    def create_network_precommit(self, context):
        """Notify all mechanism drivers during network creation.

        :raises: DB retriable error if create_network_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_network_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._check_vlan_transparency(context)
        self._call_on_drivers("create_network_precommit", context,
                              raise_db_retriable=True)

    def create_network_postcommit(self, context):
        """Notify all mechanism drivers after network creation.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_network_postcommit call fails.

        Called after the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, where the network will be deleted, triggering
        any required cleanup. There is no guarantee that all mechanism
        drivers are called in this case.
        """
        self._call_on_drivers("create_network_postcommit", context)

    def update_network_precommit(self, context):
        """Notify all mechanism drivers during network update.

        :raises: DB retriable error if update_network_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_network_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("update_network_precommit", context,
                              raise_db_retriable=True)

    def update_network_postcommit(self, context):
        """Notify all mechanism drivers after network update.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_network_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure.
        """
        self._call_on_drivers("update_network_postcommit", context,
                              continue_on_failure=True)

    def delete_network_precommit(self, context):
        """Notify all mechanism drivers during network deletion.

        :raises: DB retriable error if delete_network_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_network_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("delete_network_precommit", context,
                              raise_db_retriable=True)

    def delete_network_postcommit(self, context):
        """Notify all mechanism drivers after network deletion.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_network_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure. In
        general we expect the caller to ignore the error, as the
        network resource has already been deleted from the database
        and it doesn't make sense to undo the action by recreating the
        network.
        """
        self._call_on_drivers("delete_network_postcommit", context,
                              continue_on_failure=True)

    def create_subnet_precommit(self, context):
        """Notify all mechanism drivers during subnet creation.

        :raises: DB retriable error if create_subnet_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_subnet_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("create_subnet_precommit", context,
                              raise_db_retriable=True)

    def create_subnet_postcommit(self, context):
        """Notify all mechanism drivers after subnet creation.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_subnet_postcommit call fails.

        Called after the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, where the subnet will be deleted, triggering
        any required cleanup. There is no guarantee that all mechanism
        drivers are called in this case.
        """
        self._call_on_drivers("create_subnet_postcommit", context)

    def update_subnet_precommit(self, context):
        """Notify all mechanism drivers during subnet update.

        :raises: DB retriable error if update_subnet_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_subnet_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("update_subnet_precommit", context,
                              raise_db_retriable=True)

    def update_subnet_postcommit(self, context):
        """Notify all mechanism drivers after subnet update.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_subnet_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure.
        """
        self._call_on_drivers("update_subnet_postcommit", context,
                              continue_on_failure=True)

    def delete_subnet_precommit(self, context):
        """Notify all mechanism drivers during subnet deletion.

        :raises: DB retriable error if delete_subnet_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_subnet_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("delete_subnet_precommit", context,
                              raise_db_retriable=True)

    def delete_subnet_postcommit(self, context):
        """Notify all mechanism drivers after subnet deletion.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_subnet_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure. In
        general we expect the caller to ignore the error, as the
        subnet resource has already been deleted from the database
        and it doesn't make sense to undo the action by recreating the
        subnet.
        """
        self._call_on_drivers("delete_subnet_postcommit", context,
                              continue_on_failure=True)

    def create_port_precommit(self, context):
        """Notify all mechanism drivers during port creation.

        :raises: DB retriable error if create_port_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_port_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("create_port_precommit", context,
                              raise_db_retriable=True)

    def create_port_postcommit(self, context):
        """Notify all mechanism drivers of port creation.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver create_port_postcommit call fails.

        Called after the database transaction. Errors raised by
        mechanism drivers are left to propagate to the caller, where
        the port will be deleted, triggering any required
        cleanup. There is no guarantee that all mechanism drivers are
        called in this case.
        """
        self._call_on_drivers("create_port_postcommit", context)

    def update_port_precommit(self, context):
        """Notify all mechanism drivers during port update.

        :raises: DB retriable error if update_port_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_port_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("update_port_precommit", context,
                              raise_db_retriable=True)

    def update_port_postcommit(self, context):
        """Notify all mechanism drivers after port update.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver update_port_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure.
        """
        self._call_on_drivers("update_port_postcommit", context,
                              continue_on_failure=True)

    def delete_port_precommit(self, context):
        """Notify all mechanism drivers during port deletion.

        :raises:DB retriable error if delete_port_precommit raises them
        See neutron_lib.db.api.is_retriable for what db exception is retriable
        or neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_port_precommit call fails.

        Called within the database transaction. If a mechanism driver
        raises an exception, then a MechanismDriverError is propagated
        to the caller, triggering a rollback. There is no guarantee
        that all mechanism drivers are called in this case.
        """
        self._call_on_drivers("delete_port_precommit", context,
                              raise_db_retriable=True)

    def delete_port_postcommit(self, context):
        """Notify all mechanism drivers after port deletion.

        :raises: neutron.plugins.ml2.common.MechanismDriverError
        if any mechanism driver delete_port_postcommit call fails.

        Called after the database transaction. If any mechanism driver
        raises an error, then the error is logged but we continue to
        call every other mechanism driver. A MechanismDriverError is
        then reraised at the end to notify the caller of a failure. In
        general we expect the caller to ignore the error, as the
        port resource has already been deleted from the database
        and it doesn't make sense to undo the action by recreating the
        port.
        """
        self._call_on_drivers("delete_port_postcommit", context,
                              continue_on_failure=True)

    def bind_port(self, context):
        """Attempt to bind a port using registered mechanism drivers.

        :param context: PortContext instance describing the port

        Called outside any transaction to attempt to establish a port
        binding.
        """
        binding = context._binding
        LOG.debug("Attempting to bind port %(port)s on host %(host)s "
                  "for vnic_type %(vnic_type)s with profile %(profile)s",
                  {'port': context.current['id'],
                   'host': context.host,
                   'vnic_type': binding.vnic_type,
                   'profile': binding.profile})
        context._clear_binding_levels()
        if not self._bind_port_level(context, 0,
                                     context.network.network_segments):
            binding.vif_type = portbindings.VIF_TYPE_BINDING_FAILED
            LOG.error("Failed to bind port %(port)s on host %(host)s "
                      "for vnic_type %(vnic_type)s using segments "
                      "%(segments)s",
                      {'port': context.current['id'],
                       'host': context.host,
                       'vnic_type': binding.vnic_type,
                       'segments': context.network.network_segments})

    def _bind_port_level(self, context, level, segments_to_bind,
                         drivers=None, redoing_bottom=False):
        if drivers is None:
            drivers = self.ordered_mech_drivers

        binding = context._binding
        port_id = context.current['id']
        LOG.debug("Attempting to bind port %(port)s by drivers %(drivers)s "
                  "on host %(host)s at level %(level)s using "
                  "segments %(segments)s",
                  {'port': port_id,
                   'drivers': ','.join([driver.name for driver in drivers]),
                   'host': context.host,
                   'level': level,
                   'segments': segments_to_bind})

        if level == MAX_BINDING_LEVELS:
            LOG.error("Exceeded maximum binding levels attempting to bind "
                      "port %(port)s on host %(host)s",
                      {'port': context.current['id'],
                       'host': context.host})
            return False

        drivers = self._check_drivers_connectivity(drivers, context)
        if not drivers:
            LOG.error("Port %(port)s does not have an IP address assigned and "
                      "there are no driver with 'connectivity' = 'l2'. The "
                      "port cannot be bound.",
                      {'port': context.current['id']})
            return False

        for driver in drivers:
            if not self._check_driver_to_bind(driver, segments_to_bind,
                                              context._binding_levels):
                continue

            try:
                context._prepare_to_bind(segments_to_bind)
                driver.obj.bind_port(context)
                segment = context._new_bound_segment
                if segment:
                    pbl_obj = ports.PortBindingLevel(
                        context.plugin_context,
                        port_id=port_id,
                        host=context.host,
                        level=level,
                        driver=driver.name,
                        segment_id=segment
                    )
                    context._push_binding_level(pbl_obj)
                    next_segments = context._next_segments_to_bind
                    if next_segments:
                        # Continue binding another level.
                        if self._bind_port_level(context, level + 1,
                                                 next_segments):
                            return True
                        else:
                            LOG.warning("Failed to bind port %(port)s on "
                                        "host %(host)s at level %(lvl)s",
                                        {'port': context.current['id'],
                                         'host': context.host,
                                         'lvl': level + 1})
                            context._pop_binding_level()
                    else:
                        # NOTE(bence romsics): Consider: "In case of
                        # hierarchical port binding binding_profile.allocation
                        # [decided and sent by Placement and Nova]
                        # is meant to drive the binding only on the binding
                        # level that represents the closest physical interface
                        # to the nova server." Link to spec:
                        #
                        # https://review.opendev.org/#/c/508149/14/specs\
                        #        /rocky/minimum-bandwidth-\
                        #        allocation-placement-api.rst@582
                        #
                        # But we cannot tell if a binding level is
                        # the bottom binding level before set_binding()
                        # gets called, and that's already too late. So we
                        # must undo the last binding after set_binding()
                        # was called and redo the last level trying to
                        # bind only with one driver as inferred from
                        # the allocation. In order to undo the binding
                        # here we must also assume that each driver's
                        # bind_port() implementation is side effect free
                        # beyond calling set_binding().
                        #
                        # Also please note that technically we allow for
                        # a redo to call continue_binding() instead of
                        # set_binding() and by that turn what was supposed
                        # to be the bottom level into a non-bottom binding
                        # level. A thorough discussion is recommended if
                        # you think of taking advantage of this.
                        #
                        # Also if we find use cases requiring
                        # diamond-shaped selections of drivers on different
                        # levels (eg. driverA and driverB can be both
                        # a valid choice on level 0, but on level 1 both
                        # previous choice leads to driverC) then we need
                        # to restrict segment selection too based on
                        # traits of the allocated resource provider on
                        # the top binding_level (==0).
                        if (context.current['binding:profile'] is not None and
                                context.current[
                                    'binding:profile'].get('allocation') and
                                not redoing_bottom):
                            LOG.debug(
                                "Undo bottom bound level and redo it "
                                "according to binding_profile.allocation: %s",
                                context.current['binding:profile'][
                                    'allocation'])
                            context._pop_binding_level()
                            context._unset_binding()
                            return self._bind_port_level(
                                context, level, segments_to_bind,
                                drivers=[self._infer_driver_from_allocation(
                                    context)],
                                redoing_bottom=True)

                        # Binding complete.
                        LOG.debug("Bound port: %(port)s, "
                                  "host: %(host)s, "
                                  "vif_type: %(vif_type)s, "
                                  "vif_details: %(vif_details)s, "
                                  "binding_levels: %(binding_levels)s",
                                  {'port': port_id,
                                   'host': context.host,
                                   'vif_type': binding.vif_type,
                                   'vif_details': binding.vif_details,
                                   'binding_levels': context.binding_levels})
                        return True
            except Exception:
                LOG.exception("Mechanism driver %s failed in "
                              "bind_port",
                              driver.name)

    def _infer_driver_from_allocation(self, context):
        """Choose mechanism driver as implied by allocation in placement.

        :param context: PortContext instance describing the port
        :returns: a single MechanismDriver instance

        Ports allocated to a resource provider (ie. a physical network
        interface) in Placement have the UUID of the provider in their
        binding:profile.allocation. The choice of a physical network
        interface (as recorded in the allocation) implies a choice of
        mechanism driver too. When an allocation was received we expect
        exactly one mechanism driver to be responsible for that physical
        network interface resource provider.
        """

        drivers = []
        for driver in self.ordered_mech_drivers:
            if driver.obj.responsible_for_ports_allocation(context):
                drivers.append(driver)

        allocation = context.current['binding:profile']['allocation']

        if len(drivers) == 0:
            LOG.error("Failed to bind port %(port)s on host "
                      "%(host)s allocated on resource providers: "
                      "%(rsc_providers)s, because no mechanism driver "
                      "reports being responsible",
                      {'port': context.current['id'],
                       'host': context.host,
                       'rsc_providers': ','.join(allocation.values())})
            raise place_exc.UnknownResourceProvider(
                rsc_provider=','.join(allocation.values()))

        if len(drivers) >= 2:
            raise place_exc.AmbiguousResponsibilityForResourceProvider(
                rsc_provider=','.join(allocation.values()),
                drivers=','.join([driver.name for driver in drivers]))

        # NOTE(bence romsics): The error conditions for raising either
        # UnknownResourceProvider or AmbiguousResponsibilityForResourceProvider
        # are pretty static therefore the usual 10-times-retry of a binding
        # failure could easily be unnecessary in those cases. However at this
        # point special handling of these exceptions in the binding retry loop
        # seems like premature optimization to me since these exceptions are
        # always a sign of a misconfigured neutron deployment.

        LOG.debug("Restricting possible bindings of port %(port)s "
                  "(as inferred from placement allocation) to "
                  "mechanism driver '%(driver)s'",
                  {'port': context.current['id'],
                   'driver': drivers[0].name})

        return drivers[0]

    def is_host_filtering_supported(self):
        return all(driver.obj.is_host_filtering_supported()
                   for driver in self.ordered_mech_drivers)

    def filter_hosts_with_segment_access(
            self, context, segments, candidate_hosts, agent_getter):
        """Filter hosts with access to at least one segment.

        :returns: a subset of candidate_hosts.

        This method returns all hosts from candidate_hosts with access to a
        segment according to at least one driver.
        """
        candidate_hosts = set(candidate_hosts)
        if not self.host_filtering_supported:
            return candidate_hosts

        hosts_with_access = set()
        for driver in self.ordered_mech_drivers:
            hosts = driver.obj.filter_hosts_with_segment_access(
                context, segments, candidate_hosts, agent_getter)
            hosts_with_access |= hosts
            candidate_hosts -= hosts
            if not candidate_hosts:
                break
        return hosts_with_access

    def _check_driver_to_bind(self, driver, segments_to_bind, binding_levels):
        # To prevent a possible binding loop, don't try to bind with
        # this driver if the same driver has already bound at a higher
        # level to one of the segments we are currently trying to
        # bind. Note that it is OK for the same driver to bind at
        # multiple levels using different segments.
        segment_ids_to_bind = {s[api.ID]
                               for s in segments_to_bind}
        for level in binding_levels:
            if (level.driver == driver.name and
                    level.segment_id in segment_ids_to_bind):
                LOG.debug("segment %(segment)s is already bound "
                          "by driver %(driver)s",
                          {"segment": level.segment_id,
                           "driver": level.driver})
                return False
        return True

    def _check_drivers_connectivity(self, drivers, port_context):
        """If port does not have an IP address, driver connectivity must be l2

        A port without an IP address can be bound only to a mech driver with
        "connectivity" = "l2". "legacy" or "l3" (e.g.: Calico) drivers cannot
        have a port bound without an IP allocated.
        """
        if port_context.current.get('fixed_ips'):
            return drivers

        return [d for d in drivers if
                d.obj.connectivity == portbindings.CONNECTIVITY_L2]

    def get_workers(self):
        workers = []
        for driver in self.ordered_mech_drivers:
            workers += driver.obj.get_workers()
        return workers

class ExtensionManager(stevedore.named.NamedExtensionManager):
    """Manage extension drivers using drivers."""

    def __init__(self):
        # Ordered list of extension drivers, defining
        # the order in which the drivers are called.
        self.ordered_ext_drivers = []

        LOG.info("Configured extension driver names: %s",
                 cfg.CONF.ml2.extension_drivers)
        super(ExtensionManager, self).__init__('neutron.ml2.extension_drivers',
                                               cfg.CONF.ml2.extension_drivers,
                                               invoke_on_load=True,
                                               name_order=True)
        LOG.info("Loaded extension driver names: %s", self.names())
        self._register_drivers()

    def _register_drivers(self):
        """Register all extension drivers.

        This method should only be called once in the ExtensionManager
        constructor.
        """
        for ext in self:
            self.ordered_ext_drivers.append(ext)
        LOG.info("Registered extension drivers: %s",
                 [driver.name for driver in self.ordered_ext_drivers])

    def initialize(self):
        # Initialize each driver in the list.
        for driver in self.ordered_ext_drivers:
            LOG.info("Initializing extension driver '%s'", driver.name)
            driver.obj.initialize()

    def extension_aliases(self):
        exts = []
        for driver in self.ordered_ext_drivers:
            aliases = driver.obj.extension_aliases
            for alias in aliases:
                if not alias:
                    continue
                exts.append(alias)
                LOG.info("Got %(alias)s extension from driver '%(drv)s'",
                         {'alias': alias, 'drv': driver.name})
        return exts

    def _call_on_ext_drivers(self, method_name, plugin_context, data, result):
        """Helper method for calling a method across all extension drivers."""
        for driver in self.ordered_ext_drivers:
            try:
                getattr(driver.obj, method_name)(plugin_context, data, result)
            except Exception:
                with excutils.save_and_reraise_exception():
                    LOG.info("Extension driver '%(name)s' failed in "
                             "%(method)s",
                             {'name': driver.name, 'method': method_name})

    def process_create_network(self, plugin_context, data, result):
        """Notify all extension drivers during network creation."""
        self._call_on_ext_drivers("process_create_network", plugin_context,
                                  data, result)

    def process_update_network(self, plugin_context, data, result):
        """Notify all extension drivers during network update."""
        self._call_on_ext_drivers("process_update_network", plugin_context,
                                  data, result)

    def process_create_subnet(self, plugin_context, data, result):
        """Notify all extension drivers during subnet creation."""
        self._call_on_ext_drivers("process_create_subnet", plugin_context,
                                  data, result)

    def process_update_subnet(self, plugin_context, data, result):
        """Notify all extension drivers during subnet update."""
        self._call_on_ext_drivers("process_update_subnet", plugin_context,
                                  data, result)

    def process_create_port(self, plugin_context, data, result):
        """Notify all extension drivers during port creation."""
        self._call_on_ext_drivers("process_create_port", plugin_context,
                                  data, result)

    def process_update_port(self, plugin_context, data, result):
        """Notify all extension drivers during port update."""
        self._call_on_ext_drivers("process_update_port", plugin_context,
                                  data, result)

    def _call_on_dict_driver(self, method_name, session, base_model, result):
        for driver in self.ordered_ext_drivers:
            try:
                getattr(driver.obj, method_name)(session, base_model, result)
            except Exception:
                LOG.exception("Extension driver '%(name)s' failed in "
                              "%(method)s",
                              {'name': driver.name, 'method': method_name})
                raise ml2_exc.ExtensionDriverError(driver=driver.name)

    def extend_network_dict(self, session, base_model, result):
        """Notify all extension drivers to extend network dictionary."""
        self._call_on_dict_driver("extend_network_dict", session, base_model,
                                  result)

    def extend_subnet_dict(self, session, base_model, result):
        """Notify all extension drivers to extend subnet dictionary."""
        self._call_on_dict_driver("extend_subnet_dict", session, base_model,
                                  result)

    def extend_port_dict(self, session, base_model, result):
        """Notify all extension drivers to extend port dictionary."""
        self._call_on_dict_driver("extend_port_dict", session, base_model,
                                  result)

redpajama_set_name: RedPajamaGithub


Here you can configure the look and feel of axle. We recommend leaving most fields at their default values unless you have a good reason to modify them.
Here you can change some details about axle's player view. The Image Maximum Size sets the size of the canvas in the player view. Larger sizes mean you will see still images larger, but adds empty space around videos.
Despite what is says on the page, do not set Image Maximum Size to 0x0. This will prevent axle from generating new proxies.
Display Images As gives you the option of .jpg, .gif, or .png files for image proxies.
Watermark tells you if a watermark file is present to add to image files. This is done by creating a file called watermark.png and saving it in /Library/WebServer/Documents/axle. We do not yet support automatic watermarking on video proxies.
Empty Detail View Cache: Check this to clear all proxies of image assets from the cache.
Click Save Settings to confirm your changes.
Here you can find all the options for modifying the properties of the thumbnails axle attaches to each catalogued asset.
File Name Clipping: axle will truncate filenames longer than what you specify.
Thumbnail Size: The thumbnails axle creates will be at the resolution you enter here. This does not change their size in the axle interface, just their resolution.
If you notice a colored tint to your thumbnails, increasing the thumbnail size may fix it.
Empty Thumbnail View Cache: Check this to clear all thumbnails in axle and recreate them.
Logos Folder: axle will automatically detect image files placed in this folder and make them available to select.
Logo Selections: Here you can select the default logo for users as well as what logo is used on the log in screen.
Logos can be set for individual users on the users page.
Upload Logos: Click Choose File to open a window to add a logo to axle.
Logos should be 125x50 pixels and no larger than 20Kb.


text:
open AL ----
search__close
menu__close
Debt Overview
Presentations and Events
All Customers Manufacturers Financial Company
Press Release - April 9, 2018
Air Lease Corporation Announces Lease Placement of Airbus A330-900neo with Hi Fly
LOS ANGELES, April 9, 2018 - Air Lease Corporation (NYSE: AL; "ALC") announced a medium-term lease agreement with Hi Fly (Portugal) for one Rolls-Royce Trent 7000-powered Airbus A330-900neo aircraft. The aircraft is scheduled to deliver from ALC's order book with Airbus in June 2019.
"ALC is pleased to announce this A330-900neo lease placement with Hi Fly, a new customer for the ALC family," said Marc Baer, Executive Vice President of Air Lease Corporation. "The investment in additional A330-900neo aircraft is in line with Hi Fly's interest to maintain a modern and versatile fleet to stay competitive in the market."
The new Airbus A330-900neo offers the airline a 380-passenger aircraft that can fly 7,000 statute miles nonstop with economic and operational efficiency unmatched by current generation A330s.
Paulo Mirpuri, Hi Fly President and CEO, added, "We are delighted to start the renewal of our widebody fleet with the first brand new A330-900neo coming from ALC. The A330neo is a perfect aircraft for Hi Fly, with its new technology, modern interior and the new super-efficient Rolls Royce Trent 7000 engines, responding very well to our business needs as well as to our environmental concerns."
This press release contains forward-looking statements within the meaning of the Private Securities Litigation Reform Act of 1995, including expected delivery dates. Such statements are based on current expectations and projections about our future results, prospects and opportunities and are not guarantees of future performance. Such statements will not be updated unless required by law. Actual results and performance may differ materially from those expressed or forecasted in forward-looking statements due to a number of factors, including those discussed in our filings with the Securities and Exchange Commission.
About Air Lease Corporation (NYSE: AL)
ALC is a leading aircraft leasing company based in Los Angeles, California that has airline customers throughout the world. ALC and its team of dedicated and experienced professionals are principally engaged in purchasing commercial aircraft and leasing them to its airline customers worldwide through customized aircraft leasing and financing solutions. For more information, visit ALC's website at www.airleasecorp.com.
About Hi Fly
Hi Fly is a European airline, headquartered in Lisbon Portugal, and the largest widebody aircraft wet leasing specialist operating an all Airbus fleet, mostly Airbus A330's, A340's and soon the A380. Hi Fly has specialized for over a decade in worldwide aircraft leases and ACMI services on short, medium and long-term contracts mainly for airlines, governments, tour operators, companies and individuals. Hi Fly is EASA and IOSA certified and FAA approved, with AOC's in Portugal and Malta, and authorized to operate globally.
Mary Liz DePalma
Assistant Vice President, Investor Relations
Assistant Vice President, Finance
Email: investors@airleasecorp.com
Laura Woeste
Senior Manager, Media and Investor Relations
Email: press@airleasecorp.com
Ashley Arnold
Manager, Media & Investor Relations
2000 Avenue of the Stars, Ste. 1000N
©2020 Air Lease Corporation. All rights reserved.
Subscribe to ALC News and Investor Updates
Subscribe to receive ALC press releases and investor updates via email.