text:
Case Management & Family Support Services
Community Day Services
The Crow at 110 Online Ordering
Family Development
Home Based Support
Meet Me On Mondays
Packaging & Production Services
2020 Tree of Hope
2020 Tree of Hope Kickoff
C-U Oktoberfest
Mid-Year Appeal
EIPHC Phundraiser
DSC Foundation
ABLE Act
Ligas Consent Decree Information
Explanation of Funding
Applying for State Funded Support
State Funded Residential Programs
Employer Ed & Support
Biometric Information Security Policy
Compliment a DSC Staff Member!
Get Connected / DSC Community News
MyDSC
Meet Mark!
byStephanie Davenport
Mark Waldhoff is Chair of the DSC Board and a Real Estate Broker at Keller-Williams Realty. Mark joined the DSC board in 2012, after connecting with DSC through volunteer service projects he participated in with Keller-Williams Realty. It was through volunteer work such as painting and doing yardwork together with his co-workers that a relationship was formed between DSC and Mark. "It's an honor to be in this role and to have such a wonderful group of board members to work with, along with the staff and leadership at DSC. It's a well-run organization and I'm proud to be a part of it," said Mark.
Mark continues to volunteer with DSC by participating in DSC events such as C-U Oktoberfest, C-U in the Prairibbean and Tree of Hope. He's also volunteered at DSC holiday parties over the years. "I've always enjoyed volunteering to serve lunch during the annual Holiday party. I love walking in and everyone is happy and having fun. What really stands out to me about my involvement with DSC is that the mission is visible and tangible. When I'm around the employees I'm always impressed at how well they know each other. It's like a great, big family," said Mark.
As the Board Chair, Mark was present when the goal was unveiled for Tree of Hope campaign this year. "I appreciate the deeper connection I make to DSC each year through Tree of Hope by hearing the individual stories of the Spokesfamily, as well as the Recognition winners, and how they each arrived at their achievements."
"We always set a big, challenging goal for Tree of Hope because it's a great cause and we can put the funds to good use. We have set the goal at $175,000 this year. It's always a challenge and even more so this year, but the need is there and we're hoping the community is up for the challenge."
"Looking ahead to the future, I'm excited for where DSC is headed. There are constant changes and as board members, we are always planning for and reacting to those changes. I'm really proud of DSC's ability to adapt during these times and the continued efforts to offer new opportunities like the Crow and employment options."
Mark is married to wife Kacy, has two daughters, Tessa who is 14 and Lauren who is 12. He enjoys spending time with his family, playing golf and Cardinals baseball.
1304 West Bradley Avenue
Our community thrives when we work together for good. Discover how your help further our cause and supports our vital programs.
See what we do.
© 2021 Developmental Services Center

redpajama_set_name: RedPajamaCommonCrawl


Steak Diane is a fantastic American dish we love! It's essentially an American take on French cuisine. It's a pan-fried steak with a sauce made from pan juices and flambeed. Despite the popularity of the dish in the early 20th century, three decades ago the dish fell out of fashion. This, of course, means many modern diners haven't had it, or enjoyed a good Steak Diane in quite some time. We wanted to remedy this oversight with a slightly more modern interpretation of this nearly forgotten dish.
Whisk together the broth, Worcestershire sauce, and mustard. Set aside. Pound the steaks thin, then sprinkle both sides with salt and pepper and set aside at room temperature for 15-30 minutes.
Add 2 tablespoons butter to a skillet over medium-high heat. Pat the steaks dry with a paper towel. Turn the heat up to high, and sear the meat for 1-2 minutes, then turn and sear the other side. Remove to a cutting board, tent with foil, and let the steaks rest.
In the skillet, sauté the shallots on medium-high heat, stirring a few times. Add the mushrooms, garlic, and remaining tablespoon of butter to the pan. Stir, mixing well and stirring until the mushrooms release their liquid and the liquid evaporates (about 2 minutes). Remove pan from heat, then add the brandy and carefully light with a match to flambé. Continue to cook, lightly shaking the pan by the handle to stir until the flame dies down.
Stir in the broth mixture and bring to a boil. Cook until thickened (about 2-3 minutes), stirring often. Stir in the cream and add the steaks and any accumulated juices to the pan and cook, turning the steaks in the sauce until warmed through and the sauce has thickened. Transfer the steaks to serving plates. Stir the parsley and chives into the sauce, and pour the sauce over the steaks to serve.


text:
5 things you never knew about Peachtree Street
The Fox Theatre is a Peachtree Street landmark. credit: file photo
Access Atlanta
Peachtree Street runs north and south, directly through the history of Atlanta. Although there are no direct highway interchanges between Peachtree and its meetings with the Downtown Connector and Ga. 400, the road remains the spine of our metropolitan landscape and one of the most prominent roads in the South. And for Peachtree Street, there are thousands of stories to tell. Here are five facts about Peachtree Street you might not have known:
It was probably meant to be Pitch Tree Street
Georgia's capital city grew on lands once home to the Creek people. Among their native villages in today's Atlanta was a place called Standing Pitch Tree — pitch being another name for a pine tree. The Peachtree Trail was a path that stretched from North Georgia to the Creek's Standing Pitch Tree. The route was called the Peachtree Trail when over time settlers' incorrect pronunciation of "peach" overtook "pitch." The name was forever cemented in 1812 when construction began at the site of the old Peach (or Pitch) tree trail on a project that would be called Peachtree Road. This road began at Fort Daniel (in present-day Gwinnett County) and ran the trail to the Chattahoochee River. Portions of Peachtree Street today still trace that original route.
A tragic death
"Gone With the Wind" is commonly accepted as one of Atlanta's historical artifacts. It was written in the basement of a boarding house on Peachtree Street and set in Atlanta, and later saw its debut at the Loew's Grand Theatre on Peachtree. But it may come as a surprise to know that Peachtree Street was ultimately the demise of the novel's author. Margaret Mitchell was struck by an off-duty taxi driver driver near Peachtree Street and 13th Street while en route to see Canterbury Tale at the Peachtree Arts Theatre. Although she was rushed to Grady Hospital, Mitchell never regained consciousness and died five days after the incident on Aug. 16, 1949.
The big race is actually the biggest race
While you are likely aware of the city's annual Fourth of July kickoff — the AJC Peachtree Road Race — you may not know that the Peachtree is, in fact, the world's largest 10k. More than 60,000 participants run the 6.2-mile haul from Lenox Square to Piedmont Park.
The truth intersects the continental divide
It's sometimes shared in passing that Peachtree Street follows the Eastern Sub-Continental Divide. In actually, this high landmark runs east to west through the city, whereas Peachtree Street runs mostly north-south. The divide marks the point where water to the south flows to the Atlantic Ocean and water to the north feeds into the Gulf of Mexico. The "Native Waters" mural along Dekalb Avenue and the actual path of the divide celebrates this hydrological point with images of Georgia rivers and their associated plants and animals. A small portion of Peachtree Street actually does follow the divide, however — this fact was solidified when Whitehall Street took on the Peachtree moniker in the 1980s.
Coke put a little pep in the Peachtree step
Everyone knows that Coca-Cola is an Atlanta institution. But give Peachtree Street some credit. In late 1885, when Atlanta passed legislation that would usher in a brief period of prohibition, local pharmacist John Pemberton marketed the syrup that became a key ingredient in Coca-Cola at Jacob's Pharmacy on Peachtree Street in Five Points. Although some say the drink originated in the city of Columbus, it's a fact that customers drank the syrup, mixed with carbonated water, early on at the pharmacy on Peachtree Street.
This story was originally published by Adam Kincaid in 2015 and has since been updated.
Next: 8 places to have outdoor adventures around Atlanta
When it comes to outdoor recreation, Atlanta does not disappoint. …
5 must see-concerts in Atlanta this week
Where to find the best pies in metro Atlanta
Let your imagination run wild at Atlanta's new LEGO Discovery Center
Your guide to Atlanta's historic Sweet Auburn neighborhood
Keep up with the latest events in Atlanta
© 2023 The Atlanta Journal-Constitution. By using this website, you accept the terms of our Visitor Agreement and Privacy Policy, and understand your options regarding Ad Choices. Learn about careers @ Careers at Cox Enterprises.


text:
Kroger COO Mike Donnelly to Retire
March 5, 2021 by Ellen
Its been a more than 42 years at The Kroger, chief operating officer Mike Donnelly plans to retire this spring.
Kroger said last night that he would announce Donnelly's successor at a later date, and Donnelly also holds the title of Executive Vice President. Since December 2017, he has served as Chief Operating Officer of supermarket giant Cincinnati, responsible for overseeing Kroger Health's operations, sales of goods, marketing, supply chain, manufacturing and health services.
"With his unwavering focus on customers, Mike leads the organization to prioritize the things that matter most: food shelves, fresh food and friendly staff," said Rodney McMullen, Kroger President and CEO. "It makes our team vital, every time we can deliver results and the best experience to each customer. What matters is that Mike has trained and developed countless employees, motivated them to grow and maximize their potential, many of whom are waiting for key leadership positions across the organization. ".
Prior to his promotion to Chief Operating Officer, Donnelly (left) was Executive Vice President Commodities from September 2015 to December 2017 and Senior Vice President Commodities from July 2011 to September 2015.
Donnelly began his career in the grocery business in 1978 as an employee at Fries Food Stores in California, where he was promoted to a variety of leadership roles, including district administration. In 1995 he was named Vice President of Fry for Merchandise Sales and in 2000 he was promoted to Head of Fry's Division. He has since held the position of Senior Vice President for Kroger for Marketing of Pharmaceuticals and Daily Supplies before returning to the Fry Division as President in 2003. Donnelly was appointed Head of the Ralphs Division in 2007 and was promoted to Senior Vice President of Marketing. at Kroger in 2011.
"His passion for talent and developing a world-class team will be one of his lasting legacies," added MacMullen. "We wish Mike and his family all the best after retirement."
In total, Kroger & Company operates nearly 2,800 grocery and department stores in 35 states. Flags include: Kroger, Ralph, Dillon, Smith, King Supers, Frey, Qatar Financial Center, City Market, Irving, JC, Underbay, Baker, Gibbs, Harris Teeter, Pick'n Save, Metro Market, Mariano's, Fred Meyer., Food 4 Less, and Foods Co.
More Kroger News
Kroger, other chains to keep mask rules in place in states lifting requirement
Kroger donates 4,750 water cases to flood victims in Eastern Kentucky
Kroger Posted Mixed Results – Why Its Outlook Matters More for the Stock
Baylor student gives reasons why Walmart is superior to H-E-B


text:
Baryscapus spenceri är en stekelart som beskrevs av Graham 1991. Baryscapus spenceri ingår i släktet Baryscapus och familjen finglanssteklar.

Artens utbredningsområde är:
 Nederländerna.
 Sverige.

Arten är reproducerande i Sverige. Inga underarter finns listade.

Källor

Finglanssteklar
spenceri

redpajama_set_name: RedPajamaWikipedia


This project is called 30 Gresham Street, and it involved the supply of limestone for flooring, coverings and columns for interior application on a building renovation project.
Gresham Street is one of the main streets in the financial district of London. The project we had the opportunity to be involved in was related to the renovation of a building located in this central part of London – United Kingdom.
Our part of the project involved the supply of Moleanos Limestone and Cabeca Veada Limestone, to be applied on flooring, coverings and some columns. All this work was for interior application. The limestone supplied by our company was applied on different levels throughout the building. The level of natural stone quality of this project was very high, to the point that later the building was awarded with the Natural Stone Award 2004 from the British magazine Natural Stone.


This Internet-Draft will expire on December 13, 2018.
root zone KSK key roll.
not what the user impact of the KSK roll will be.
represented in the label as 00042).
Wessels for providing comments in the form of a pull request.


text:
package dk.statsbiblioteket.doms.client.objects;

import dk.statsbiblioteket.doms.client.exceptions.ServerOperationFailed;

/**
 * Created by IntelliJ IDEA.
 * User: abr
 * Date: 11/2/11
 * Time: 10:23 AM
 * To change this template use File | Settings | File Templates.
 */
public interface DigitalObjectFactory {
    DigitalObject getDigitalObject(String pid) throws ServerOperationFailed;

    //CentralWebservice getApi();
}

redpajama_set_name: RedPajamaGithub


text:
Venue: Festival Hall
We Will Rock You (fast), Let Me Entertain You, Somebody To Love, Fat Bottomed Girls, Death On Two Legs, Killer Queen, Bicycle Race, I'm In Love With My Car, Get Down Make Love, You're My Best Friend, Now I'm Here, Don't Stop Me Now, Spread Your Wings, Dreamer's Ball, Love Of My Life, '39, It's Late, Brighton Rock, Keep Yourself Alive, Bohemian Rhapsody, Tie Your Mother Down, Sheer Heart Attack, We Will Rock You, We Are The Champions, God Save The Queen
This picture was taken from the "Ultimate Dreamer" bootleg listed below. There are a few hundred copies of the bootleg, and each one has a random few pictures out of dozens that were taken at the Osaka shows.
The first night in Osaka is another great early tour show. Freddie, although his range is limited, continues to sing with much passion. Somebody To Love is a great version.
Before Fat Bottomed Girls, Freddie says, "This is all about you little girls with great big tits." He receives no reaction, and then continues, "I'm sure you know what I mean. You're just not reacting." While he says that, a male audience member obnoxiously shouts out, "Ohhhh yeah!" Freddie, clearly pleased, says, "Yeeeeeees, you do."
In the middle section of Don't Stop Me Now, Brian accidentally hits a B chord when it's supposed to be in C, so he constucts a riff for a few bars, making it sound as fluid as possible, eventually returning to the B chord, as if he meant to play it that way all along. The band soon makes their way into the usual guitar solo, and it's a very tasty one.
Recording length: 124 minutes (2 CD, complete)
Quality: A-
Lineage: "Zoom 1979" (LLX) silvers
This tape used for this 1994 bootleg runs much too slow.
The sound itself is nearly excellent, but the mix gets a bit muddy at times, especially when the audience is about as loud as the band. The best sound quality is during Get Down Make Love, Love Of My Life, Brighton Rock, and any other moment when the audience is calm. That said, these recordings from the two nights in Osaka are amongst the best live recordings of Queen available.
The taper or someone close to him coughs now and again, and unfortunately it's usually clearly heard. He taped the following night's show as well, and his coughing is even more prominent on that recording.
Lineage: "Ultimate Dreamer" (Wardour) silvers
This is probably sourced from the Zoom bootleg, as the only difference is that it now runs at the correct speed. Like Zoom, it's a 4 CD set of both nights in Osaka.
Here's a link to the always-reliable GS review: http://www.collectorsmusicreviews.com
In 2019 Wardour released another bootleg of this tape called "Definitive Osaka 1979." The content is identical, apart from a slight EQ job.


text:
enioilproducts
Your business, our energy
Products and solutions for business and customers Italy and abroad
Working and growing together
The platform dedicated to Eni's current and future suppliers
All Press Releases News Stories Video Podcast Projects Publications Photogallery Focus
Go to myeni
Access with password
Rapid Access
Added to your menu Removed from your menu
Add to your menu Remove
Topic added to your menu Topic removed from your menu
Global energy scenarios
Format added to your menu Format removed from your menu
A sustainable material for wind energy
Wood, an ecological alternative in the offshore eolic energy sector.
by Maria Pia Rossignaud
Producing renewable energy from sustainable materials could soon be a reality. In Gothenburg, Sweden, the industrial design company Modvion has designed and built the first wind turbine blade made almost entirely of wood. It could just be the standard bearer for a real revolution in the industry.
An alternative to the steel
The Swedish company has installed a 30 metre-high tower, built in layers with interlocking glulam components (apart from the turbine which, inevitably, is still steel). The strong point of this new construction method is that you can assemble the wind turbine on site instead of transporting it whole, as you would with a steel model.
Producing the steel used in today's turbine towers means producing more CO2. In addition, their height of around 100 metres and minimum diameter at the base of 4.5 metres translate into enormous relocation costs, not to mention logistical difficulties. In Europe and North America (where the technology is most used) that makes the structures more expensive.
Wood, on the other hand, besides being a renewable and sustainable material, is much lighter than steel and can be transported in components, thus reducing transport costs. And that's not all. The trees used for the towers throughout their life cycle would absorb CO2, thus offsetting the gas emitted during their construction and transport. The result is a carbon-neutral wind turbine. Modvion is also considering using recycled wood, taking circularity to the next level in this hypothetical system for producing and recycling energy and materials.
New peaks for wind power
The potential to build on this research has not escaped the European Innovation Council, which has decided, through the European Commission, to allocate 6.5 million euros to the project. Modvion has stated that it will use these funds to build a commercial tower and a plant in the Gothenburg area, where this technology will become an industry. Otto Lundman, CEO of the company, spoke enthusiastically about the project at a press conference: "This is a major breakthrough that paves the way for the next generation of wind turbines. Laminated wood is stronger than steel... and by building in modules, the wind turbines can be taller... we also reduce carbon dioxide emissions in manufacturing."
Wooden towers have the additional advantage of a modular structure that can easily be made higher than that of their steel counterparts. This opens the door to new experiments. According to some studies, a turbine mounted on a 140 metre-high tower, for example, can generate 33% more electricity than the same turbine on an 80 metre-high tower.
The 30 metre blade, built for the Chalmers University of Technology's wind power technology centre and installed in Gothenburg, is a one-to-five scale version of the traditional 150 metre model and is scheduled to be installed on a commercial scale in 2022.
The key role of continuous research
The construction of this new wind turbine, which has been a source of great interest both in Sweden and around the EU, was made possible by the support of the Västra Götaland regional council and the Swedish Energy Agency. Sara Fogelström, coordinator of the Swedish Wind Power Technology Centre (SWPTC) says on the Chalmers website: "For a university, it is unique to have access to a test wind turbine that is made to scale and equipped with that many different sensors. The ability to control and adjust the various parameters of the wind turbine enables new research opportunities." The website goes on to say that "Within a couple of decades, wind power is expected to be the largest, or second largest, energy source for electricity generation in Sweden. It puts high demands on cost-effective and sustainable wind power turbines with high electricity generation. Integrating wind turbines into the grid requires many different competences working together. Chalmers hosts the... Centre, which brings together players."
Read more about technologies
Selected content on this issue.
Solar power in the "oven"
The power of the Italian sea
The energy tower
We are an energy company. We concretely support a just energy transition, with the objective of preserving our planet and promoting an efficient and sustainable access to energy for all. Our work is based on passion and innovation, on our unique strengths and skills, on the equal dignity of each person, recognizing diversity as a key value for human development, on the responsibility, integrity and transparency of our actions. We believe in the value of long term partnerships with the countries and communities where we operate, bringing long-lasting prosperity for all.
Piazzale Enrico Mattei,1 00144 Rome, Italy
Via Emilia, 1 and Piazza Ezio Vanoni, 1 20097 San Donato Milanese, Milan, Italy
Company Share Capital
€ 4.005.358.876,00 paid up
Rome Company Register
ENI ON SOCIAL MEDIA
Info Reserved Area
This website uses cookies to show you adverts and offer you services customised according to the preferences you have shown while browsing online. For further information please refer to our cookie policy.
I agree Download PDF


text:
/*
 * adapted from https://github.com/atom/underscore-plus/blob/master/src/underscore-plus.coffee
 */

const MAC_MODIFIER_KEYMAP = {
  alt: '\u2325',
  cmd: '\u2318',
  ctrl: '\u2303',
  down: '\u2193',
  enter: '\u23ce',
  left: '\u2190',
  option: '\u2325',
  right: '\u2192',
  shift: '\u21e7',
  up: '\u2191',
};

const NON_MAC_MODIFIER_KEYMAP = {
  alt: 'Alt',
  cmd: 'Cmd',
  ctrl: 'Ctrl',
  down: 'Down',
  enter: 'Enter',
  left: 'Left',
  option: 'Alt',
  right: 'Right',
  shift: 'Shift',
  up: 'Up',
};

// Human key combos should always explicitly state the shift key. This map is a disambiguator.
// 'shift-version': 'no-shift-version'
const SHIFT_KEYMAP = {
  '_': '-',
  ':': ';',
  '?': '/',
  '"': '\'',
  '{': '[',
  '}': ']',
  '+': '=',
  '<': ',',
  '>': '.',
  '|': '\\',
  '~': '`',
};

const FN_KEY_RE = /f[0-9]{1,2}/;

// $FlowIssue
function flatten<T>(arr: Array<T | Array<T>>): Array<T> {
  let flattened = [];
  for (const el of arr) {
    if (Array.isArray(el)) {
      flattened = flattened.concat(flatten(el));
    } else {
      flattened.push(el);
    }
  }
  return flattened;
}

function capitalize(word: string): string {
  const first = word[0] || '';
  const rest = word.slice(1);
  return first.toUpperCase() + rest;
}

function humanizeKey(key: string, platform: ?string): string | Array<string> {
  if (!key) {
    return key;
  }
  const modifierKeyMap = platform === 'darwin' ? MAC_MODIFIER_KEYMAP : NON_MAC_MODIFIER_KEYMAP;
  if (modifierKeyMap[key]) {
    return modifierKeyMap[key];
  }
  if (key.length === 1) {
    if (SHIFT_KEYMAP[key]) {
      return [modifierKeyMap.shift, SHIFT_KEYMAP[key]];
    }
    const uppercase = key.toUpperCase();
    if (key === uppercase && uppercase !== key.toLowerCase()) {
      return [modifierKeyMap.shift, uppercase];
    }
    return uppercase;
  }
  if (FN_KEY_RE.test(key)) {
    return key.toUpperCase();
  }
  return platform === 'darwin' ? key : capitalize(key);
}

/**
 * Humanize the keystroke according to platform conventions. This method
 * attempts to mirror the text the given keystroke would have if displayed in
 * a system menu.
 *
 * @param keystroke A String keystroke to humanize such as `ctrl-O`.
 * @param platform An optional String platform to humanize for (default: `process.platform`).
 * @return a humanized representation of the keystroke.
 */
export default function humanizeKeystroke(keystroke: string, platform_: ?string): string {
  let platform = platform_;
  if (!keystroke) {
    return keystroke;
  }
  platform = platform || process.platform;
  const separator = platform === 'darwin' ? '' : '+';
  let key;
  let keys;
  let splitKeystroke;
  const keystrokes = keystroke.split(' ');
  const humanizedKeystrokes = [];
  for (let i = 0; i < keystrokes.length; i++) {
    const currentKeystroke = keystrokes[i];
    splitKeystroke = currentKeystroke.split('-');
    keys = [];
    for (let index = 0; index < splitKeystroke.length; index++) {
      key = splitKeystroke[index];
      if (key === '' && splitKeystroke[index - 1] === '') {
        key = '-';
      }
      if (key) {
        keys.push(humanizeKey(key, platform));
      }
    }
    keys = Array.from(new Set(flatten(keys)));
    humanizedKeystrokes.push(keys.join(separator));
  }
  return humanizedKeystrokes.join(' ');
}


PaleoCleanse Plus™ 21 Day Detoxification Program (includes shaker bottle). PaleoCleanse Plus™ is a comprehensive, science-based nutritional program designed to support safe and effective detoxification. This is accomplished by providing the nutrients needed to support and balance phase I and II metabolic pathways and to promote healthy liver function and elimination.* Everything is consolidated into packets to make the program easy to follow and to ensure that individuals on the program do not miss any necessary nutrients.
Other ingredients: Hydroxypropyl methylcellulose, microcrystalline cellulose, magnesium stearate, silicon dioxide. Chios Gum Mastic is the resinous material obtained from the Pistacia lentiscus tree, grown on the island of Chios in Greece, where it has traditionally been used as a healthy food for the gastrointestinal tract.*Other ingredients: Hydroxypropyl methylcellulose, microcrystalline cellulose, magnesium stearate, silicon dioxide.
Orthobiotoic: Guaranteed Potency at Ingestion. Because probiotics are live cultures, product freshness becomes a top priority. Ortho Biotic is carefully handled and manufactured often throughout the year, ensuring optimal product freshness for maximized potency at ingestion. We are so confident of our freshness that we guarantee Ortho Biotic to be at full label strength at ingestion.
Green Healing Wellness Center represents the changing tide in healthcare today. We focus on strengthening the inherent ability of the body to achieve and maintain health.
Our mission is to spread the knowledge of Natural Medicine and holistic living to improve the health of our planet and people that live on it.
Our nutritional products are unconditionally guaranteed for quality, freshness and labeled potency. If for any reason you are not thoroughly satisfied with your purchase, you can return the product(s) within the first 30 days for a full 100% refund.


text:
Home - Car News - Toyota unveiled 2019 Corolla at Beijing
Toyota unveiled 2019 Corolla at Beijing
by Swati Sanchayi on Friday, May 11 2018
The Japanese automaker Toyota Motor Corporation has announced at the Beijing Motor Show that it has planned to launch plug-in hybrid electric vehicle (PHEV) versions of its ongoing "Corolla" and "Levin" passenger cars in 2019 along with a zero emission battery electric vehicle (BEV) model based on its "C-HR" / "IZOA"* crossover compact SUV for the Chinese market in 2020.
The new versions of these Corolla and Levin cars due in 2019 are claimed to be capable of going 30 miles in all-electric mode and in 2019, Toyota will start producing them in China, marking Toyota's debut in overseas production of plug-in hybrid vehicles. Toyota plans to introduce 10 new electrified vehicles in China by 2020 and this newly announced plug-in cars are a part of it.
The plug-in hybrid vehicle versions of the 2019 Corolla and Levin were unveiled on the opening day of the Beijing Motor Show in China. Both of these models are expected to be a result of the Chinese government's requirement for a certain quota of a car brand's sales to be electric in order to control the emission. The demand for plug-in cars in China is so large that Toyota has sold 1,40,000 electrified cars alone there in 2017. The figure represented cumulative total of electrified vehicles sold in the country to approximately 350,000 units which is 40 per cent of the total sales of the electric cars by Toyota till date, and the automaker plans to continue improving its electrified-vehicle lineup.
The Japanese automotive manufacturer has plans to produce the electric motors, batteries and inverters for its plug-in models for the hybrid market. In order to suffice the increasing demand for its plug-in cars, Toyota is going to raise its production capacity for the nickel-metal hydride battery modules at Sinogy Toyota Automotive Energy System Co., Ltd., and Corun PEVE Automotive Battery Co., Ltd., to 2,20,000 units by 2020. It is also opening a battery testing facility in China with the name Toyota Motor Engineering and Manufacturing.
Toyota recently revealed that it is working on commercializing solid-state batteries by the early 2020s and if it achieves this target, the Japanese carmaker would be the first to do so. The technology will enable the batteries to store more energy than an equivalent of lithium-ion batteries and is likely to become a game changer for the electric vehicles.
The company has been working alongside its Chinese partners and members of the Toyota Group in order to build a local production base for key components. The efforts include the launch of production of transaxles for hybrid electric vehicles at Toyota Motor Auto Parts Co., Ltd., which took place in 2015.
Toyota Motor Corporation is exploring potential applications for its fuel cell technology for the fuel cell electric vehicles in China. In 2017, the company started a three-year verification-test program for the Chinese market that uses Toyota's "Mirai" FCEV, which has expanded the scope of feasibility studies to include the commercial vehicles like buses too.
Kazuhiro Kobayashi, Senior Managing Officer and Chief Executive Officer, China Region, Toyota stated at the Beijing Motor Show that the company is steadily and confidently advancing all aspects of our environmental strategy in China, which is the world's most-advanced country in electrification.
Swati Sanchayi
A diverse bilingual (English and Hindi) Copywriter and Content Creator based in New Delhi, India. With a degree in Journalism, I always had an inclination towards writing.
As a writer, I have worked on content related to automobile, technology, travel, lifestyle, photography and many more.
20 Years Of Toyota Kirloskar Motors In India
Confirmed: Toyota Alphard Based Lexus LM MPV
FY2018-19: Toyota Sales Grew by 7 Per Cent
Thursday, Apr 04 2019
Toyota Becomes The Most Searched For Car Brand Globally
Toyota And JAXA Enhance Partnership For Space Exploration
Tuesday, Mar 19 2019
Toyota To Announce Price Hike In April
March Offers On Toyota Vehicles
Monday, Mar 18 2019
Toyota India February 2019 Sales Report


text:
Autograph Partnerships: Midland Road Development Acquired by Curo
Autograph Partnerships is a new initiative that aims to respond to the lack of affordable housing in the South West using the considerable experience of the Autograph team to provide a complete turnkey solution to housing associations and registered providers. Our team offers the knowledge and expertise to manage the entire process from site finding, land acquisition, obtaining planning permission, building and delivering finished units. We aim to provide a development route that offers both the quantity and variety of affordable housing stock that housing associations and registered providers are searching for.
We're proud to announce that our first Partnerships venture with Bath-based housing association Curo, will deliver 32 affordable homes at Midland Road, that we anticipate will be ready for occupation by Summer 2022. The majority of the one, two and three-bedroom apartments at Midland Road will be let to people on Bristol City Council's housing list – 16 at social rent and nine at an affordable rent. Another seven apartments will be sold through the affordable home ownership scheme, Shared Ownership.
There is an acute need for affordable housing in the South West of England. The National Housing Federation estimates that the region now needs "15,000 new affordable or intermediate need homes each year, of which 8,000 should be for social rent". Homes for the South West, a group of chief executives from some of the largest housing associations in the region, describe the current situation as "A regional housing crisis". They also warn against a race to the bottom by developers stating "While it is vital that we deliver more affordable homes more quickly, it is also important that the housing sector does not lose sight of the importance of delivering homes that stand up to modern scrutiny".
There is a desire within the housing association and registered provider community to develop a broader and more representative housing stock than has often been available through the section 106 provision of large scale housing developers. Victor da Cunha, Chief Executive of Curo said: "A successful, growing city such as Bristol needs to have the widest possible range of good quality housing in high value areas, such as the city centre, not only to meet the housing needs of its diverse residents but also to continue to be successful into the future. Lockdown has reminded us about the importance of 'home' and that society functions best when our bus drivers, care workers and shop assistants live locally and are part of the community."
At Midland Road, we've been delighted to be able to provide an end-to-end service for Curo. We've acquired and assembled the site, secured planning and entered a build phase which will ultimately deliver thoughtfully designed superior specification affordable homes to residents in the centre of Bristol. The ability to identify and unlock the potential of this site is a testament to the wealth of experience and specialist knowledge within the Partnerships senior team. Our size and flexibility as a local developer make us one of the few specialist providers in the South West capable of investing the time and resource to create the custom specification residential schemes that registered providers need.


text:
@interface ABI44_0_0RNPanGestureHandler : ABI44_0_0RNGestureHandler
@end


text:
package allocator

import (
	"context"
	"net"
	"runtime/debug"
	"strconv"
	"testing"
	"time"

	"github.com/docker/go-events"
	"github.com/docker/swarmkit/api"
	"github.com/docker/swarmkit/manager/state"
	"github.com/docker/swarmkit/manager/state/store"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func init() {
	// set artificially low retry interval for testing
	retryInterval = 5 * time.Millisecond
}

func TestAllocator(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)

	// Predefined node-local networkTestNoDuplicateIPs
	p := &api.Network{
		ID: "one_unIque_id",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "pred_bridge_network",
				Labels: map[string]string{
					"com.docker.swarm.predefined": "true",
				},
			},
			DriverConfig: &api.Driver{Name: "bridge"},
		},
	}

	// Node-local swarm scope network
	nln := &api.Network{
		ID: "another_unIque_id",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "swarm-macvlan",
			},
			DriverConfig: &api.Driver{Name: "macvlan"},
		},
	}

	// Try adding some objects to store before allocator is started
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "ingress-nw-id",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "default-ingress",
				},
				Ingress: true,
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))

		n1 := &api.Network{
			ID: "testID1",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "test1",
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, n1))

		s1 := &api.Service{
			ID: "testServiceID1",
			Spec: api.ServiceSpec{
				Annotations: api.Annotations{
					Name: "service1",
				},
				Task: api.TaskSpec{
					Networks: []*api.NetworkAttachmentConfig{
						{
							Target: "testID1",
						},
					},
				},
				Endpoint: &api.EndpointSpec{
					Mode: api.ResolutionModeVirtualIP,
					Ports: []*api.PortConfig{
						{
							Name:          "portName",
							Protocol:      api.ProtocolTCP,
							TargetPort:    8000,
							PublishedPort: 8001,
						},
					},
				},
			},
		}
		assert.NoError(t, store.CreateService(tx, s1))

		t1 := &api.Task{
			ID: "testTaskID1",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			Networks: []*api.NetworkAttachment{
				{
					Network: n1,
				},
			},
		}
		assert.NoError(t, store.CreateTask(tx, t1))

		t2 := &api.Task{
			ID: "testTaskIDPreInit",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			ServiceID:    "testServiceID1",
			DesiredState: api.TaskStateRunning,
		}
		assert.NoError(t, store.CreateTask(tx, t2))

		// Create the predefined node-local network with one service
		assert.NoError(t, store.CreateNetwork(tx, p))

		sp1 := &api.Service{
			ID: "predServiceID1",
			Spec: api.ServiceSpec{
				Annotations: api.Annotations{
					Name: "predService1",
				},
				Task: api.TaskSpec{
					Networks: []*api.NetworkAttachmentConfig{
						{
							Target: p.ID,
						},
					},
				},
				Endpoint: &api.EndpointSpec{Mode: api.ResolutionModeDNSRoundRobin},
			},
		}
		assert.NoError(t, store.CreateService(tx, sp1))

		tp1 := &api.Task{
			ID: "predTaskID1",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			Networks: []*api.NetworkAttachment{
				{
					Network: p,
				},
			},
		}
		assert.NoError(t, store.CreateTask(tx, tp1))

		// Create the the swarm level node-local network with one service
		assert.NoError(t, store.CreateNetwork(tx, nln))

		sp2 := &api.Service{
			ID: "predServiceID2",
			Spec: api.ServiceSpec{
				Annotations: api.Annotations{
					Name: "predService2",
				},
				Task: api.TaskSpec{
					Networks: []*api.NetworkAttachmentConfig{
						{
							Target: nln.ID,
						},
					},
				},
				Endpoint: &api.EndpointSpec{Mode: api.ResolutionModeDNSRoundRobin},
			},
		}
		assert.NoError(t, store.CreateService(tx, sp2))

		tp2 := &api.Task{
			ID: "predTaskID2",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			Networks: []*api.NetworkAttachment{
				{
					Network: nln,
				},
			},
		}
		assert.NoError(t, store.CreateTask(tx, tp2))

		return nil
	}))

	netWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateNetwork{}, api.EventDeleteNetwork{})
	defer cancel()
	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{}, api.EventDeleteTask{})
	defer cancel()
	serviceWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateService{}, api.EventDeleteService{})
	defer cancel()

	// Start allocator
	go func() {
		assert.NoError(t, a.Run(context.Background()))
	}()
	defer a.Stop()

	// Now verify if we get network and tasks updated properly
	watchNetwork(t, netWatch, false, isValidNetwork)
	watchTask(t, s, taskWatch, false, isValidTask) // t1
	watchTask(t, s, taskWatch, false, isValidTask) // t2
	watchService(t, serviceWatch, false, nil)

	// Verify no allocation was done for the node-local networks
	var (
		ps *api.Network
		sn *api.Network
	)
	s.View(func(tx store.ReadTx) {
		ps = store.GetNetwork(tx, p.ID)
		sn = store.GetNetwork(tx, nln.ID)

	})
	assert.NotNil(t, ps)
	assert.NotNil(t, sn)
	// Verify no allocation was done for tasks on node-local networks
	var (
		tp1 *api.Task
		tp2 *api.Task
	)
	s.View(func(tx store.ReadTx) {
		tp1 = store.GetTask(tx, "predTaskID1")
		tp2 = store.GetTask(tx, "predTaskID2")
	})
	assert.NotNil(t, tp1)
	assert.NotNil(t, tp2)
	assert.Equal(t, tp1.Networks[0].Network.ID, p.ID)
	assert.Equal(t, tp2.Networks[0].Network.ID, nln.ID)
	assert.Nil(t, tp1.Networks[0].Addresses, "Non nil addresses for task on node-local network")
	assert.Nil(t, tp2.Networks[0].Addresses, "Non nil addresses for task on node-local network")

	// Add new networks/tasks/services after allocator is started.
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		n2 := &api.Network{
			ID: "testID2",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "test2",
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, n2))
		return nil
	}))

	watchNetwork(t, netWatch, false, isValidNetwork)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		s2 := &api.Service{
			ID: "testServiceID2",
			Spec: api.ServiceSpec{
				Annotations: api.Annotations{
					Name: "service2",
				},
				Networks: []*api.NetworkAttachmentConfig{
					{
						Target: "testID2",
					},
				},
				Endpoint: &api.EndpointSpec{},
			},
		}
		assert.NoError(t, store.CreateService(tx, s2))
		return nil
	}))

	watchService(t, serviceWatch, false, nil)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t2 := &api.Task{
			ID: "testTaskID2",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			ServiceID:    "testServiceID2",
			DesiredState: api.TaskStateRunning,
		}
		assert.NoError(t, store.CreateTask(tx, t2))
		return nil
	}))

	watchTask(t, s, taskWatch, false, isValidTask)

	// Now try adding a task which depends on a network before adding the network.
	n3 := &api.Network{
		ID: "testID3",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "test3",
			},
		},
	}

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t3 := &api.Task{
			ID: "testTaskID3",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			DesiredState: api.TaskStateRunning,
			Networks: []*api.NetworkAttachment{
				{
					Network: n3,
				},
			},
		}
		assert.NoError(t, store.CreateTask(tx, t3))
		return nil
	}))

	// Wait for a little bit of time before adding network just to
	// test network is not available while task allocation is
	// going through
	time.Sleep(10 * time.Millisecond)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNetwork(tx, n3))
		return nil
	}))

	watchNetwork(t, netWatch, false, isValidNetwork)
	watchTask(t, s, taskWatch, false, isValidTask)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteTask(tx, "testTaskID3"))
		return nil
	}))
	watchTask(t, s, taskWatch, false, isValidTask)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t5 := &api.Task{
			ID: "testTaskID5",
			Spec: api.TaskSpec{
				Networks: []*api.NetworkAttachmentConfig{
					{
						Target: "testID2",
					},
				},
			},
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			DesiredState: api.TaskStateRunning,
			ServiceID:    "testServiceID2",
		}
		assert.NoError(t, store.CreateTask(tx, t5))
		return nil
	}))
	watchTask(t, s, taskWatch, false, isValidTask)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteNetwork(tx, "testID3"))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteService(tx, "testServiceID2"))
		return nil
	}))
	watchService(t, serviceWatch, false, nil)

	// Try to create a task with no network attachments and test
	// that it moves to ALLOCATED state.
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t4 := &api.Task{
			ID: "testTaskID4",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			DesiredState: api.TaskStateRunning,
		}
		assert.NoError(t, store.CreateTask(tx, t4))
		return nil
	}))
	watchTask(t, s, taskWatch, false, isValidTask)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		n2 := store.GetNetwork(tx, "testID2")
		require.NotEqual(t, nil, n2)
		assert.NoError(t, store.UpdateNetwork(tx, n2))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork)
	watchNetwork(t, netWatch, true, nil)

	// Try updating service which is already allocated with no endpointSpec
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		s := store.GetService(tx, "testServiceID1")
		s.Spec.Endpoint = nil

		assert.NoError(t, store.UpdateService(tx, s))
		return nil
	}))
	watchService(t, serviceWatch, false, nil)

	// Try updating task which is already allocated
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t2 := store.GetTask(tx, "testTaskID2")
		require.NotEqual(t, nil, t2)
		assert.NoError(t, store.UpdateTask(tx, t2))
		return nil
	}))
	watchTask(t, s, taskWatch, false, isValidTask)
	watchTask(t, s, taskWatch, true, nil)

	// Try adding networks with conflicting network resources and
	// add task which attaches to a network which gets allocated
	// later and verify if task reconciles and moves to ALLOCATED.
	n4 := &api.Network{
		ID: "testID4",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "test4",
			},
			DriverConfig: &api.Driver{
				Name: "overlay",
				Options: map[string]string{
					"com.docker.network.driver.overlay.vxlanid_list": "328",
				},
			},
		},
	}

	n5 := n4.Copy()
	n5.ID = "testID5"
	n5.Spec.Annotations.Name = "test5"
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNetwork(tx, n4))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNetwork(tx, n5))
		return nil
	}))
	watchNetwork(t, netWatch, true, nil)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t6 := &api.Task{
			ID: "testTaskID6",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			DesiredState: api.TaskStateRunning,
			Networks: []*api.NetworkAttachment{
				{
					Network: n5,
				},
			},
		}
		assert.NoError(t, store.CreateTask(tx, t6))
		return nil
	}))
	watchTask(t, s, taskWatch, true, nil)

	// Now remove the conflicting network.
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteNetwork(tx, n4.ID))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork)
	watchTask(t, s, taskWatch, false, isValidTask)

	// Try adding services with conflicting port configs and add
	// task which is part of the service whose allocation hasn't
	// happened and when that happens later and verify if task
	// reconciles and moves to ALLOCATED.
	s3 := &api.Service{
		ID: "testServiceID3",
		Spec: api.ServiceSpec{
			Annotations: api.Annotations{
				Name: "service3",
			},
			Endpoint: &api.EndpointSpec{
				Ports: []*api.PortConfig{
					{
						Name:          "http",
						TargetPort:    80,
						PublishedPort: 8080,
					},
					{
						PublishMode: api.PublishModeHost,
						Name:        "http",
						TargetPort:  80,
					},
				},
			},
		},
	}

	s4 := s3.Copy()
	s4.ID = "testServiceID4"
	s4.Spec.Annotations.Name = "service4"
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateService(tx, s3))
		return nil
	}))
	watchService(t, serviceWatch, false, nil)
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateService(tx, s4))
		return nil
	}))
	watchService(t, serviceWatch, true, nil)

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		t7 := &api.Task{
			ID: "testTaskID7",
			Status: api.TaskStatus{
				State: api.TaskStateNew,
			},
			ServiceID:    "testServiceID4",
			DesiredState: api.TaskStateRunning,
		}
		assert.NoError(t, store.CreateTask(tx, t7))
		return nil
	}))
	watchTask(t, s, taskWatch, true, nil)

	// Now remove the conflicting service.
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteService(tx, s3.ID))
		return nil
	}))
	watchService(t, serviceWatch, false, nil)
	watchTask(t, s, taskWatch, false, isValidTask)
}

func TestNoDuplicateIPs(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()

	// Try adding some objects to store before allocator is started
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "ingress-nw-id",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "default-ingress",
				},
				Ingress: true,
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.0.0.0/24",
						Gateway: "10.0.0.1",
					},
				},
			},
			DriverState: &api.Driver{},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))
		n1 := &api.Network{
			ID: "testID1",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "test1",
				},
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.1.0.0/24",
						Gateway: "10.1.0.1",
					},
				},
			},
			DriverState: &api.Driver{},
		}
		assert.NoError(t, store.CreateNetwork(tx, n1))

		s1 := &api.Service{
			ID: "testServiceID1",
			Spec: api.ServiceSpec{
				Annotations: api.Annotations{
					Name: "service1",
				},
				Task: api.TaskSpec{
					Networks: []*api.NetworkAttachmentConfig{
						{
							Target: "testID1",
						},
					},
				},
				Endpoint: &api.EndpointSpec{
					Mode: api.ResolutionModeVirtualIP,
					Ports: []*api.PortConfig{
						{
							Name:          "portName",
							Protocol:      api.ProtocolTCP,
							TargetPort:    8000,
							PublishedPort: 8001,
						},
					},
				},
			},
		}
		assert.NoError(t, store.CreateService(tx, s1))

		return nil
	}))

	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{}, api.EventDeleteTask{})
	defer cancel()

	assignedIPs := make(map[string]string)
	hasUniqueIP := func(fakeT assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
		if len(task.Networks) == 0 {
			panic("missing networks")
		}
		if len(task.Networks[0].Addresses) == 0 {
			panic("missing network address")
		}

		assignedIP := task.Networks[0].Addresses[0]
		oldTaskID, present := assignedIPs[assignedIP]
		if present && task.ID != oldTaskID {
			t.Fatalf("task %s assigned duplicate IP %s, previously assigned to task %s", task.ID, assignedIP, oldTaskID)
		}
		assignedIPs[assignedIP] = task.ID
		return true
	}

	reps := 100
	for i := 0; i != reps; i++ {
		assert.NoError(t, s.Update(func(tx store.Tx) error {
			t2 := &api.Task{
				// The allocator iterates over the tasks in
				// lexical order, so number tasks in descending
				// order. Note that the problem this test was
				// meant to trigger also showed up with tasks
				// numbered in ascending order, but it took
				// until the 52nd task.
				ID: "testTaskID" + strconv.Itoa(reps-i),
				Status: api.TaskStatus{
					State: api.TaskStateNew,
				},
				ServiceID:    "testServiceID1",
				DesiredState: api.TaskStateRunning,
			}
			assert.NoError(t, store.CreateTask(tx, t2))

			return nil
		}))
		a, err := New(s, nil, nil)
		assert.NoError(t, err)
		assert.NotNil(t, a)

		// Start allocator
		go func() {
			assert.NoError(t, a.Run(context.Background()))
		}()

		// Confirm task gets a unique IP
		watchTask(t, s, taskWatch, false, hasUniqueIP)
		a.Stop()
	}
}

func TestAllocatorRestoreForDuplicateIPs(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()
	// Create 3 services with 1 task each
	numsvcstsks := 3
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "ingress-nw-id",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "default-ingress",
				},
				Ingress: true,
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.0.0.0/24",
						Gateway: "10.0.0.1",
					},
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))

		for i := 0; i != numsvcstsks; i++ {
			svc := &api.Service{
				ID: "testServiceID" + strconv.Itoa(i),
				Spec: api.ServiceSpec{
					Annotations: api.Annotations{
						Name: "service" + strconv.Itoa(i),
					},
					Endpoint: &api.EndpointSpec{
						Mode: api.ResolutionModeVirtualIP,

						Ports: []*api.PortConfig{
							{
								Name:          "",
								Protocol:      api.ProtocolTCP,
								TargetPort:    8000,
								PublishedPort: uint32(8001 + i),
							},
						},
					},
				},
				Endpoint: &api.Endpoint{
					Ports: []*api.PortConfig{
						{
							Name:          "",
							Protocol:      api.ProtocolTCP,
							TargetPort:    8000,
							PublishedPort: uint32(8001 + i),
						},
					},
					VirtualIPs: []*api.Endpoint_VirtualIP{
						{
							NetworkID: "ingress-nw-id",
							Addr:      "10.0.0." + strconv.Itoa(2+i) + "/24",
						},
					},
				},
			}
			assert.NoError(t, store.CreateService(tx, svc))
		}
		return nil
	}))

	for i := 0; i != numsvcstsks; i++ {
		assert.NoError(t, s.Update(func(tx store.Tx) error {
			tsk := &api.Task{
				ID: "testTaskID" + strconv.Itoa(i),
				Status: api.TaskStatus{
					State: api.TaskStateNew,
				},
				ServiceID:    "testServiceID" + strconv.Itoa(i),
				DesiredState: api.TaskStateRunning,
			}
			assert.NoError(t, store.CreateTask(tx, tsk))
			return nil
		}))
	}

	assignedVIPs := make(map[string]bool)
	assignedIPs := make(map[string]bool)
	hasNoIPOverlapServices := func(fakeT assert.TestingT, service *api.Service) bool {
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs), 0)
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs[0].Addr), 0)

		assignedVIP := service.Endpoint.VirtualIPs[0].Addr
		if assignedVIPs[assignedVIP] {
			t.Fatalf("service %s assigned duplicate IP %s", service.ID, assignedVIP)
		}
		assignedVIPs[assignedVIP] = true
		if assignedIPs[assignedVIP] {
			t.Fatalf("a task and service %s have the same IP %s", service.ID, assignedVIP)
		}
		return true
	}

	hasNoIPOverlapTasks := func(fakeT assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
		assert.NotEqual(fakeT, len(task.Networks), 0)
		assert.NotEqual(fakeT, len(task.Networks[0].Addresses), 0)

		assignedIP := task.Networks[0].Addresses[0]
		if assignedIPs[assignedIP] {
			t.Fatalf("task %s assigned duplicate IP %s", task.ID, assignedIP)
		}
		assignedIPs[assignedIP] = true
		if assignedVIPs[assignedIP] {
			t.Fatalf("a service and task %s have the same IP %s", task.ID, assignedIP)
		}
		return true
	}

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)
	// Start allocator
	go func() {
		assert.NoError(t, a.Run(context.Background()))
	}()
	defer a.Stop()

	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{}, api.EventDeleteTask{})
	defer cancel()

	serviceWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateService{}, api.EventDeleteService{})
	defer cancel()

	// Confirm tasks have no IPs that overlap with the services VIPs on restart
	for i := 0; i != numsvcstsks; i++ {
		watchTask(t, s, taskWatch, false, hasNoIPOverlapTasks)
		watchService(t, serviceWatch, false, hasNoIPOverlapServices)
	}
}

// TestAllocatorRestartNoEndpointSpec covers the leader election case when the service Spec
// does not contain the EndpointSpec.
// The expected behavior is that the VIP(s) are still correctly populated inside
// the IPAM and that no configuration on the service is changed.
func TestAllocatorRestartNoEndpointSpec(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()
	// Create 3 services with 1 task each
	numsvcstsks := 3
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "overlay1",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "net1",
				},
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.0.0.0/24",
						Gateway: "10.0.0.1",
					},
				},
			},
			DriverState: &api.Driver{},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))

		for i := 0; i != numsvcstsks; i++ {
			svc := &api.Service{
				ID: "testServiceID" + strconv.Itoa(i),
				Spec: api.ServiceSpec{
					Annotations: api.Annotations{
						Name: "service" + strconv.Itoa(i),
					},
					// Endpoint: &api.EndpointSpec{
					// 	Mode: api.ResolutionModeVirtualIP,
					// },
					Task: api.TaskSpec{
						Networks: []*api.NetworkAttachmentConfig{
							{
								Target: "overlay1",
							},
						},
					},
				},
				Endpoint: &api.Endpoint{
					Spec: &api.EndpointSpec{
						Mode: api.ResolutionModeVirtualIP,
					},
					VirtualIPs: []*api.Endpoint_VirtualIP{
						{
							NetworkID: "overlay1",
							Addr:      "10.0.0." + strconv.Itoa(2+2*i) + "/24",
						},
					},
				},
			}
			assert.NoError(t, store.CreateService(tx, svc))
		}
		return nil
	}))

	for i := 0; i != numsvcstsks; i++ {
		assert.NoError(t, s.Update(func(tx store.Tx) error {
			tsk := &api.Task{
				ID: "testTaskID" + strconv.Itoa(i),
				Status: api.TaskStatus{
					State: api.TaskStateNew,
				},
				ServiceID:    "testServiceID" + strconv.Itoa(i),
				DesiredState: api.TaskStateRunning,
				Networks: []*api.NetworkAttachment{
					{
						Network: &api.Network{
							ID: "overlay1",
						},
					},
				},
			}
			assert.NoError(t, store.CreateTask(tx, tsk))
			return nil
		}))
	}

	expectedIPs := map[string]string{
		"testServiceID0": "10.0.0.2/24",
		"testServiceID1": "10.0.0.4/24",
		"testServiceID2": "10.0.0.6/24",
		"testTaskID0":    "10.0.0.3/24",
		"testTaskID1":    "10.0.0.5/24",
		"testTaskID2":    "10.0.0.7/24",
	}
	assignedIPs := make(map[string]bool)
	hasNoIPOverlapServices := func(fakeT assert.TestingT, service *api.Service) bool {
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs), 0)
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs[0].Addr), 0)
		assignedVIP := service.Endpoint.VirtualIPs[0].Addr
		if assignedIPs[assignedVIP] {
			t.Fatalf("service %s assigned duplicate IP %s", service.ID, assignedVIP)
		}
		assignedIPs[assignedVIP] = true
		ip, ok := expectedIPs[service.ID]
		assert.True(t, ok)
		assert.Equal(t, ip, assignedVIP)
		delete(expectedIPs, service.ID)
		return true
	}

	hasNoIPOverlapTasks := func(fakeT assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
		assert.NotEqual(fakeT, len(task.Networks), 0)
		assert.NotEqual(fakeT, len(task.Networks[0].Addresses), 0)
		assignedIP := task.Networks[0].Addresses[0]
		if assignedIPs[assignedIP] {
			t.Fatalf("task %s assigned duplicate IP %s", task.ID, assignedIP)
		}
		assignedIPs[assignedIP] = true
		ip, ok := expectedIPs[task.ID]
		assert.True(t, ok)
		assert.Equal(t, ip, assignedIP)
		delete(expectedIPs, task.ID)
		return true
	}

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)
	// Start allocator
	go func() {
		assert.NoError(t, a.Run(context.Background()))
	}()
	defer a.Stop()

	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{}, api.EventDeleteTask{})
	defer cancel()

	serviceWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateService{}, api.EventDeleteService{})
	defer cancel()

	// Confirm tasks have no IPs that overlap with the services VIPs on restart
	for i := 0; i != numsvcstsks; i++ {
		watchTask(t, s, taskWatch, false, hasNoIPOverlapTasks)
		watchService(t, serviceWatch, false, hasNoIPOverlapServices)
	}
	assert.Len(t, expectedIPs, 0)
}

// TestAllocatorRestoreForUnallocatedNetwork tests allocator restart
// scenarios where there is a combination of allocated and unallocated
// networks and tests whether the restore logic ensures the networks
// services and tasks that were preallocated are allocated correctly
// followed by the allocation of unallocated networks prior to the
// restart.
func TestAllocatorRestoreForUnallocatedNetwork(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()
	// Create 3 services with 1 task each
	numsvcstsks := 3
	var n1 *api.Network
	var n2 *api.Network
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "ingress-nw-id",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "default-ingress",
				},
				Ingress: true,
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.0.0.0/24",
						Gateway: "10.0.0.1",
					},
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))

		n1 = &api.Network{
			ID: "testID1",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "test1",
				},
			},
			IPAM: &api.IPAMOptions{
				Driver: &api.Driver{},
				Configs: []*api.IPAMConfig{
					{
						Subnet:  "10.1.0.0/24",
						Gateway: "10.1.0.1",
					},
				},
			},
			DriverState: &api.Driver{},
		}
		assert.NoError(t, store.CreateNetwork(tx, n1))

		n2 = &api.Network{
			// Intentionally named testID0 so that in restore this network
			// is looked into first
			ID: "testID0",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "test2",
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, n2))

		for i := 0; i != numsvcstsks; i++ {
			svc := &api.Service{
				ID: "testServiceID" + strconv.Itoa(i),
				Spec: api.ServiceSpec{
					Annotations: api.Annotations{
						Name: "service" + strconv.Itoa(i),
					},
					Task: api.TaskSpec{
						Networks: []*api.NetworkAttachmentConfig{
							{
								Target: "testID1",
							},
						},
					},
					Endpoint: &api.EndpointSpec{
						Mode: api.ResolutionModeVirtualIP,
						Ports: []*api.PortConfig{
							{
								Name:          "",
								Protocol:      api.ProtocolTCP,
								TargetPort:    8000,
								PublishedPort: uint32(8001 + i),
							},
						},
					},
				},
				Endpoint: &api.Endpoint{
					Ports: []*api.PortConfig{
						{
							Name:          "",
							Protocol:      api.ProtocolTCP,
							TargetPort:    8000,
							PublishedPort: uint32(8001 + i),
						},
					},
					VirtualIPs: []*api.Endpoint_VirtualIP{
						{
							NetworkID: "ingress-nw-id",
							Addr:      "10.0.0." + strconv.Itoa(2+i) + "/24",
						},
						{
							NetworkID: "testID1",
							Addr:      "10.1.0." + strconv.Itoa(2+i) + "/24",
						},
					},
				},
			}
			assert.NoError(t, store.CreateService(tx, svc))
		}
		return nil
	}))

	for i := 0; i != numsvcstsks; i++ {
		assert.NoError(t, s.Update(func(tx store.Tx) error {
			tsk := &api.Task{
				ID: "testTaskID" + strconv.Itoa(i),
				Status: api.TaskStatus{
					State: api.TaskStateNew,
				},
				Spec: api.TaskSpec{
					Networks: []*api.NetworkAttachmentConfig{
						{
							Target: "testID1",
						},
					},
				},
				ServiceID:    "testServiceID" + strconv.Itoa(i),
				DesiredState: api.TaskStateRunning,
			}
			assert.NoError(t, store.CreateTask(tx, tsk))
			return nil
		}))
	}

	assignedIPs := make(map[string]bool)
	expectedIPs := map[string]string{
		"testServiceID0": "10.1.0.2/24",
		"testServiceID1": "10.1.0.3/24",
		"testServiceID2": "10.1.0.4/24",
		"testTaskID0":    "10.1.0.5/24",
		"testTaskID1":    "10.1.0.6/24",
		"testTaskID2":    "10.1.0.7/24",
	}
	hasNoIPOverlapServices := func(fakeT assert.TestingT, service *api.Service) bool {
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs), 0)
		assert.NotEqual(fakeT, len(service.Endpoint.VirtualIPs[0].Addr), 0)
		assignedVIP := service.Endpoint.VirtualIPs[1].Addr
		if assignedIPs[assignedVIP] {
			t.Fatalf("service %s assigned duplicate IP %s", service.ID, assignedVIP)
		}
		assignedIPs[assignedVIP] = true
		ip, ok := expectedIPs[service.ID]
		assert.True(t, ok)
		assert.Equal(t, ip, assignedVIP)
		delete(expectedIPs, service.ID)
		return true
	}

	hasNoIPOverlapTasks := func(fakeT assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
		assert.NotEqual(fakeT, len(task.Networks), 0)
		assert.NotEqual(fakeT, len(task.Networks[0].Addresses), 0)
		assignedIP := task.Networks[1].Addresses[0]
		if assignedIPs[assignedIP] {
			t.Fatalf("task %s assigned duplicate IP %s", task.ID, assignedIP)
		}
		assignedIPs[assignedIP] = true
		ip, ok := expectedIPs[task.ID]
		assert.True(t, ok)
		assert.Equal(t, ip, assignedIP)
		delete(expectedIPs, task.ID)
		return true
	}

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)
	// Start allocator
	go func() {
		assert.NoError(t, a.Run(context.Background()))
	}()
	defer a.Stop()

	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{}, api.EventDeleteTask{})
	defer cancel()

	serviceWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateService{}, api.EventDeleteService{})
	defer cancel()

	// Confirm tasks have no IPs that overlap with the services VIPs on restart
	for i := 0; i != numsvcstsks; i++ {
		watchTask(t, s, taskWatch, false, hasNoIPOverlapTasks)
		watchService(t, serviceWatch, false, hasNoIPOverlapServices)
	}
}

func TestNodeAllocator(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)

	var node1FromStore *api.Node
	node1 := &api.Node{
		ID: "nodeID1",
	}

	// Try adding some objects to store before allocator is started
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// populate ingress network
		in := &api.Network{
			ID: "ingress",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "ingress",
				},
				Ingress: true,
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, in))

		n1 := &api.Network{
			ID: "overlayID1",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "overlayID1",
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, n1))

		// this network will never be used for any task
		nUnused := &api.Network{
			ID: "overlayIDUnused",
			Spec: api.NetworkSpec{
				Annotations: api.Annotations{
					Name: "overlayIDUnused",
				},
			},
		}
		assert.NoError(t, store.CreateNetwork(tx, nUnused))

		assert.NoError(t, store.CreateNode(tx, node1))

		return nil
	}))

	nodeWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateNode{}, api.EventDeleteNode{})
	defer cancel()
	netWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateNetwork{}, api.EventDeleteNetwork{})
	defer cancel()
	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{})
	defer cancel()

	// Start allocator
	go func() {
		assert.NoError(t, a.Run(context.Background()))
	}()
	defer a.Stop()

	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// create a task assigned to this node that has a network attachment on
		// n1
		t1 := &api.Task{
			ID:           "task1",
			NodeID:       node1.ID,
			DesiredState: api.TaskStateRunning,
			Spec: api.TaskSpec{
				Networks: []*api.NetworkAttachmentConfig{
					{
						Target: "overlayID1",
					},
				},
			},
		}

		return store.CreateTask(tx, t1)
	}))

	// validate that the task is created
	watchTask(t, s, taskWatch, false, isValidTask)

	// Validate node has 2 LB IP address (1 for each network).
	watchNetwork(t, netWatch, false, isValidNetwork)                                      // ingress
	watchNetwork(t, netWatch, false, isValidNetwork)                                      // overlayID1
	watchNetwork(t, netWatch, false, isValidNetwork)                                      // overlayIDUnused
	watchNode(t, nodeWatch, false, isValidNode, node1, []string{"ingress", "overlayID1"}) // node1

	// Add a node and validate it gets a LB ip only on ingress, as it has no
	// tasks assigned.
	node2 := &api.Node{
		ID: "nodeID2",
	}
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNode(tx, node2))
		return nil
	}))
	watchNode(t, nodeWatch, false, isValidNode, node2, []string{"ingress"}) // node2

	// Add a network and validate that nothing has changed in the nodes
	n2 := &api.Network{
		ID: "overlayID2",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "overlayID2",
			},
		},
	}
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNetwork(tx, n2))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork) // overlayID2
	// nothing should change, no updates
	watchNode(t, nodeWatch, true, isValidNode, node1, []string{"ingress", "overlayID1"}) // node1
	watchNode(t, nodeWatch, true, isValidNode, node2, []string{"ingress"})               // node2

	// add a task and validate that the node gets the network for the task
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// create a task assigned to this node that has a network attachment on
		// n1
		t2 := &api.Task{
			ID:           "task2",
			NodeID:       node2.ID,
			DesiredState: api.TaskStateRunning,
			Spec: api.TaskSpec{
				Networks: []*api.NetworkAttachmentConfig{
					{
						Target: "overlayID2",
					},
				},
			},
		}

		return store.CreateTask(tx, t2)
	}))
	// validate that the task is created
	watchTask(t, s, taskWatch, false, isValidTask)

	// validate that node2 gets a new attachment and node1 stays the same
	watchNode(t, nodeWatch, false, isValidNode, node2, []string{"ingress", "overlayID2"}) // node2
	watchNode(t, nodeWatch, true, isValidNode, node1, []string{"ingress", "overlayID1"})  // node1

	// add another task with the same network to a node and validate that it
	// still only has 1 attachment for that network
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		// create a task assigned to this node that has a network attachment on
		// n1
		t3 := &api.Task{
			ID:           "task3",
			NodeID:       node1.ID,
			DesiredState: api.TaskStateRunning,
			Spec: api.TaskSpec{
				Networks: []*api.NetworkAttachmentConfig{
					{
						Target: "overlayID1",
					},
				},
			},
		}

		return store.CreateTask(tx, t3)
	}))

	// validate that the task is created
	watchTask(t, s, taskWatch, false, isValidTask)

	// validate that nothing changes
	watchNode(t, nodeWatch, true, isValidNode, node1, []string{"ingress", "overlayID1"}) // node1
	watchNode(t, nodeWatch, true, isValidNode, node2, []string{"ingress", "overlayID2"}) // node2

	// now remove that task we just created, and validate that the node still
	// has an attachment for the other task
	// Remove a node and validate remaining node has 2 LB IP addresses
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteTask(tx, "task1"))
		return nil
	}))

	// validate that nothing changes
	watchNode(t, nodeWatch, true, isValidNode, node1, []string{"ingress", "overlayID1"}) // node1
	watchNode(t, nodeWatch, true, isValidNode, node2, []string{"ingress", "overlayID2"}) // node2

	// now remove another task. this time the attachment on the node should be
	// removed as well
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteTask(tx, "task2"))
		return nil
	}))

	watchNode(t, nodeWatch, false, isValidNode, node2, []string{"ingress"})              // node2
	watchNode(t, nodeWatch, true, isValidNode, node1, []string{"ingress", "overlayID1"}) // node1

	// Remove a node and validate remaining node has 2 LB IP addresses
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.DeleteNode(tx, node2.ID))
		return nil
	}))
	watchNode(t, nodeWatch, false, nil, nil, nil) // node2
	s.View(func(tx store.ReadTx) {
		node1FromStore = store.GetNode(tx, node1.ID)
	})

	isValidNode(t, node1, node1FromStore, []string{"ingress", "overlayID1"})

	// Validate that a LB IP address is not allocated for node-local networks
	p := &api.Network{
		ID: "bridge",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "pred_bridge_network",
				Labels: map[string]string{
					"com.docker.swarm.predefined": "true",
				},
			},
			DriverConfig: &api.Driver{Name: "bridge"},
		},
	}
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		assert.NoError(t, store.CreateNetwork(tx, p))
		return nil
	}))
	watchNetwork(t, netWatch, false, isValidNetwork) // bridge

	s.View(func(tx store.ReadTx) {
		node1FromStore = store.GetNode(tx, node1.ID)
	})

	isValidNode(t, node1, node1FromStore, []string{"ingress", "overlayID1"})
}

// TestNodeAttachmentOnLeadershipChange tests that a Node which is only partly
// allocated during a leadership change is correctly allocated afterward
func TestNodeAttachmentOnLeadershipChange(t *testing.T) {
	s := store.NewMemoryStore(nil)
	assert.NotNil(t, s)
	defer s.Close()

	a, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a)

	net1 := &api.Network{
		ID: "ingress",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "ingress",
			},
			Ingress: true,
		},
	}

	net2 := &api.Network{
		ID: "net2",
		Spec: api.NetworkSpec{
			Annotations: api.Annotations{
				Name: "net2",
			},
		},
	}

	node1 := &api.Node{
		ID: "node1",
	}

	task1 := &api.Task{
		ID:           "task1",
		NodeID:       node1.ID,
		DesiredState: api.TaskStateRunning,
		Spec:         api.TaskSpec{},
	}

	// this task is not yet assigned. we will assign it to node1 after running
	// the allocator a 2nd time. we should create it now so that its network
	// attachments are allocated.
	task2 := &api.Task{
		ID:           "task2",
		DesiredState: api.TaskStateRunning,
		Spec: api.TaskSpec{
			Networks: []*api.NetworkAttachmentConfig{
				{
					Target: "net2",
				},
			},
		},
	}

	// before starting the allocator, populate with these
	assert.NoError(t, s.Update(func(tx store.Tx) error {
		require.NoError(t, store.CreateNetwork(tx, net1))
		require.NoError(t, store.CreateNetwork(tx, net2))
		require.NoError(t, store.CreateNode(tx, node1))
		require.NoError(t, store.CreateTask(tx, task1))
		require.NoError(t, store.CreateTask(tx, task2))
		return nil
	}))

	// now start the allocator, let it allocate all of these objects, and then
	// stop it. it's easier to do this than to manually assign all of the
	// values

	nodeWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateNode{}, api.EventDeleteNode{})
	defer cancel()
	netWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateNetwork{}, api.EventDeleteNetwork{})
	defer cancel()
	taskWatch, cancel := state.Watch(s.WatchQueue(), api.EventUpdateTask{})
	defer cancel()

	ctx, ctxCancel := context.WithCancel(context.Background())
	go func() {
		assert.NoError(t, a.Run(ctx))
	}()

	// validate that everything gets allocated
	watchNetwork(t, netWatch, false, isValidNetwork)
	watchNetwork(t, netWatch, false, isValidNetwork)
	watchNode(t, nodeWatch, false, isValidNode, node1, []string{"ingress"})
	watchTask(t, s, taskWatch, false, isValidTask)

	// once everything is created, go ahead and stop the allocator
	a.Stop()
	ctxCancel()

	// now update task2 to assign it to node1
	s.Update(func(tx store.Tx) error {
		task := store.GetTask(tx, task2.ID)
		require.NotNil(t, task)
		// make sure it has 1 network attachment
		assert.Len(t, task.Networks, 1)
		task.NodeID = node1.ID
		require.NoError(t, store.UpdateTask(tx, task))
		return nil
	})

	// and now we'll start a new allocator.
	a2, err := New(s, nil, nil)
	assert.NoError(t, err)
	assert.NotNil(t, a2)

	ctx2, cancel2 := context.WithCancel(context.Background())
	go func() {
		assert.NoError(t, a2.Run(ctx2))
	}()
	defer a2.Stop()
	defer cancel2()

	// now we should see the node get allocated
	watchNode(t, nodeWatch, false, isValidNode, node1, []string{"ingress"})
	watchNode(t, nodeWatch, false, isValidNode, node1, []string{"ingress", "net2"})
}

func isValidNode(t assert.TestingT, originalNode, updatedNode *api.Node, networks []string) bool {

	if !assert.Equal(t, originalNode.ID, updatedNode.ID) {
		return false
	}

	if !assert.Equal(t, len(updatedNode.Attachments), len(networks)) {
		return false
	}

	for _, na := range updatedNode.Attachments {
		if !assert.Equal(t, len(na.Addresses), 1) {
			return false
		}
	}

	return true
}

func isValidNetwork(t assert.TestingT, n *api.Network) bool {
	if _, ok := n.Spec.Annotations.Labels["com.docker.swarm.predefined"]; ok {
		return true
	}
	return assert.NotEqual(t, n.IPAM.Configs, nil) &&
		assert.Equal(t, len(n.IPAM.Configs), 1) &&
		assert.Equal(t, n.IPAM.Configs[0].Range, "") &&
		assert.Equal(t, len(n.IPAM.Configs[0].Reserved), 0) &&
		isValidSubnet(t, n.IPAM.Configs[0].Subnet) &&
		assert.NotEqual(t, net.ParseIP(n.IPAM.Configs[0].Gateway), nil)
}

func isValidTask(t assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
	return isValidNetworkAttachment(t, task) &&
		isValidEndpoint(t, s, task) &&
		assert.Equal(t, task.Status.State, api.TaskStatePending)
}

func isValidNetworkAttachment(t assert.TestingT, task *api.Task) bool {
	if len(task.Networks) != 0 {
		return assert.Equal(t, len(task.Networks[0].Addresses), 1) &&
			isValidSubnet(t, task.Networks[0].Addresses[0])
	}

	return true
}

func isValidEndpoint(t assert.TestingT, s *store.MemoryStore, task *api.Task) bool {
	if task.ServiceID != "" {
		var service *api.Service
		s.View(func(tx store.ReadTx) {
			service = store.GetService(tx, task.ServiceID)
		})

		if service == nil {
			return true
		}

		return assert.Equal(t, service.Endpoint, task.Endpoint)

	}

	return true
}

func isValidSubnet(t assert.TestingT, subnet string) bool {
	_, _, err := net.ParseCIDR(subnet)
	return assert.NoError(t, err)
}

type mockTester struct{}

func (m mockTester) Errorf(format string, args ...interface{}) {
}

// Returns a timeout given whether we should expect a timeout:  In the case where we do expect a timeout,
// the timeout should be short, because it's not very useful to wait long amounts of time just in case
// an unexpected event comes in - a short timeout should catch an incorrect event at least often enough
// to make the test flaky and alert us to the problem. But in the cases where we don't expect a timeout,
// the timeout should be on the order of several seconds, so the test doesn't fail just because it's run
// on a relatively slow system, or there's a load spike.
func getWatchTimeout(expectTimeout bool) time.Duration {
	if expectTimeout {
		return 350 * time.Millisecond
	}
	return 5 * time.Second
}

func watchNode(t *testing.T, watch chan events.Event, expectTimeout bool,
	fn func(t assert.TestingT, originalNode, updatedNode *api.Node, networks []string) bool,
	originalNode *api.Node,
	networks []string) {
	for {

		var node *api.Node
		select {
		case event := <-watch:
			if n, ok := event.(api.EventUpdateNode); ok {
				node = n.Node.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, originalNode, node, networks)) {
					return
				}
			}

			if n, ok := event.(api.EventDeleteNode); ok {
				node = n.Node.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, originalNode, node, networks)) {
					return
				}
			}

		case <-time.After(getWatchTimeout(expectTimeout)):
			if !expectTimeout {
				if node != nil && fn != nil {
					fn(t, originalNode, node, networks)
				}

				t.Fatal("timed out before watchNode found expected node state", string(debug.Stack()))
			}

			return
		}
	}
}

func watchNetwork(t *testing.T, watch chan events.Event, expectTimeout bool, fn func(t assert.TestingT, n *api.Network) bool) {
	for {
		var network *api.Network
		select {
		case event := <-watch:
			if n, ok := event.(api.EventUpdateNetwork); ok {
				network = n.Network.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, network)) {
					return
				}
			}

			if n, ok := event.(api.EventDeleteNetwork); ok {
				network = n.Network.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, network)) {
					return
				}
			}

		case <-time.After(getWatchTimeout(expectTimeout)):
			if !expectTimeout {
				if network != nil && fn != nil {
					fn(t, network)
				}

				t.Fatal("timed out before watchNetwork found expected network state", string(debug.Stack()))
			}

			return
		}
	}
}

func watchService(t *testing.T, watch chan events.Event, expectTimeout bool, fn func(t assert.TestingT, n *api.Service) bool) {
	for {
		var service *api.Service
		select {
		case event := <-watch:
			if s, ok := event.(api.EventUpdateService); ok {
				service = s.Service.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, service)) {
					return
				}
			}

			if s, ok := event.(api.EventDeleteService); ok {
				service = s.Service.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, service)) {
					return
				}
			}

		case <-time.After(getWatchTimeout(expectTimeout)):
			if !expectTimeout {
				if service != nil && fn != nil {
					fn(t, service)
				}

				t.Fatalf("timed out before watchService found expected service state\n stack = %s", string(debug.Stack()))
			}

			return
		}
	}
}

func watchTask(t *testing.T, s *store.MemoryStore, watch chan events.Event, expectTimeout bool, fn func(t assert.TestingT, s *store.MemoryStore, n *api.Task) bool) {
	for {
		var task *api.Task
		select {
		case event := <-watch:
			if t, ok := event.(api.EventUpdateTask); ok {
				task = t.Task.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, s, task)) {
					return
				}
			}

			if t, ok := event.(api.EventDeleteTask); ok {
				task = t.Task.Copy()
				if fn == nil || (fn != nil && fn(mockTester{}, s, task)) {
					return
				}
			}

		case <-time.After(getWatchTimeout(expectTimeout)):
			if !expectTimeout {
				if task != nil && fn != nil {
					fn(t, s, task)
				}

				t.Fatalf("timed out before watchTask found expected task state %s", debug.Stack())
			}

			return
		}
	}
}


Greetings from the Asia-Pacific Federation on Giftedness!
We are pleased to share with you the APFG Newsletter Special Issue on STREAM* Education for Gifted Students in Asia-Pacific.
If you have any suggestions or comments, please do not hesitate to contact me.
We are pleased to share with you the APGF Newsletter Special Issue on Creativity, Leadership and Talent Development for Gifted Students in Asia-Pacific.
We hope you will enjoy and benefit from this sharing of knowledge and experience. Please feel free to pass on the APGF Newsletter to your colleagues, friends, students, administrators and policy makers. You can also invite them to join our conference in August. Registration details for APCG2018 could be found at the conference webpage.
If you have any suggestions or comments, please do not hesitate to contact me at email: mtyuen@hku.hk.
The Asia-Pacific Federation on Giftedness (APFG) is now accepting bid proposals to host the 2020 and 2022 Asia-Pacific Conference on Giftedness (APCG).
The deadline for bid will be 31 July 2018. Please submit your bid by e-mail to APFG President Professor Kyungbin Park at kbpark@gachon.ac.kr or the secretary Quek Chwee Geok at cgquek@gmail.com. Bids will be reviewed by the APFG Executive Committee (ExCo) Members. Potentials bidders are also encouraged to participate in the 2018 Bangkok 15th APCG Conference to present their proposal at the APFG meetings, and answer questions from the Executive Committee members. The successful bidder will be announced during the 2018 Bangkok Conference.
For more details, please see attached documents.
National Taiwan Normal University is delighted to be hosting the Biennial Conference of the IRATDE for the first time in 2019. With its theme of "Nurturing Potentiality into Full Bloom and into Excellence", the event will feature a strong program of keynote lectures, invited symposia, paper and poster presentations, exhibition, school visits, pre-conference workshops, and post conference tour.
Attending the 2019 IRATDE conference is a great way to share worldwide experiences, gain networking contacts and greater understanding of emerging issues in talent development and excellence. Please mark your calendars and plan to attend.
Conference theme: "Inspiration, Motivation, and Creativity: Leading the Way to Giftedness"
* 1 October 2017 - 30 June 2018: Online registration "Early Bird Rate"
* 1-31 July 2018: Online registration "Regular Rate"
CTY Ireland is delighted to host the 16th Conference of the European Council for High Ability! We hope that many of you will choose to join us in Dublin for ECHA 2018 and experience our vibrant home.


text:
Ptičja direktiva je neformalno ime za Direktivo Sveta 79/409/EGS z dne 2. aprila 1979 o ohranjanju prosto živečih ptic.

Ptičja direktiva je najstarejši predpis Evropske unije s področja varstva narave. Direktiva je vzpostavila obsežen sistem varstva za vse prostoživeče vrste ptic v Uniji. Sprejeta je bila kot odgovor na naraščajočo zaskrbljenost zaradi upadanja populacij ptic, kar je posledica onesnaženj, uničevanja habitatov in prekomernega lova. Države članice so se strinjale, da so ptice - mnoge vrste so selivke - skupna naravna dediščina vse Unije, zaradi česar njihovo varstvo zahteva sodelovanje vseh članic.

Direktiva priznava, da je izgubljanje in degradiranje habitatov največja grožnja ohranjanju ptic v Uniji. Zato veliko pozornost posveča ohranjanju habitatov ogroženih vrst ptic. Države članice morajo za vse vrste ptic iz Dodatka I direktive in za vse redno pojavljajoče se migratorne vrste ptic, ki so potrebne varstva, oblikovati posebna območja varstva (Special Protection Area - SPA), imenovana tudi območja Natura 2000. Države članice so na SPA območjih dolžne zagotavljati, da so populacije varovanih vrst ptic v ugodnem stanju.

Ptičja direktiva je bila večkrat spremenjena in dopolnjena. Največ sprememb je bilo na Dodatkih, kjer so seznami vrst ptic z različnimi varstvenimi režimi. Dodatki so se spreminjali ob vsaki širitvi Evropske unije. Zadnja prečiščena verzija (t. i. kodificirana različica) Ptičje direktive z dne 30. novembra 2009 nosi oznako 2009/147/ES.

Zunanje povezave
 Ptičja direktiva, prečiščeno besedilo Uradno besedilo v Slovenščini, objavljeno v Uradnem listu Evropske unije 26.1.2010
 Uradne spletne strani Evropske komisije o Ptičji direktivi
 Brošura Evropske komisije (2006): Sodbe Evropskega sodišča povezane z Ptičjo in Habitatno direktivo

1979 v politiki

Ornitologija
Direktive Evropske skupnosti
Varstvo narave
Natura 2000
Okoljsko pravo


Picasso and Audrey Hepburn both famously made the sailor shirt a wardrobe staple. Our Bateau napkin is our interpretation of this nautical motif. Perfect for al fresco dining or for lunches on board mega yachts.
Buy Bateau Napkin by for only $16 Dining at Jung Lee NY.


Pittsburgh, PA- Not only will the halls and rooms of Carnegie Museum of Art (CMOA) overflow with sculpture, photography, painting, and installation when Carnegie International, 57th Edition, 2018 opens on October 13, the facade of the building will be transformed by art as well. Two monumental outdoor works will attract passers-by and invite visitors into the museum, where arresting projects will greet them just within the museum doors. We are pleased to preview these four works which—in their exceptional use of scale, texture, color, and sound—anticipate the range and depth of the work further in.
The immense works of Ghanaian artist El Anatsui have shimmered and rippled over buildings and parks the world over. His piece for the International will span the museum's 30 by 160-foot facade, transforming the way visitors see the building. This work moves from a reflective expanse to an undulating palisade of folded printing plates, to one of the artist's signature sheets of wired-together liquor bottle tops. Rich in hue and historic association, Anatsui's materials create space around the Richard Serra sculpture on the museum's plaza. Connecting old and new, color and light, Africa and America, this work also has a local connection: the printing plates are sourced from Pittsburgh's Knepper Press. In addition, the piece is being fabricated by sculptor Dee Briggs in her converted firehouse studio in Wilkinsburg with a crew of her neighbors working around the clock toward installation day.
Tavares Strachan's art gives body to the unseen. His new project Encyclopedia of Invisibility continues his ongoing project to catalogue people and things left out of official records and canons: a slave artist, a Catalan insurrectionist, the first woman admitted to Florence's Academia di Arte del Disegno. Increasingly drawn into the orbit of science, Strachan has launched blown-glass rockets fueled by sugarcane into space and is the first artist-in-residence at Seattle's Allen Institute for research. For his contribution to the International, the Bahamian artist is making a work for the museum's facade that responds to the museum's history. Grand in scope and daring in design, the project will be brought to light at the International's opening in an electrifying moment of connection, affirmation, and radiance.
The images created by the peripatetic photographer Mimi Cherono Ng'ok arise from her travels around the world: Abidjan, Accra, Berlin, Dakar, Johannesburg, Kampala, Kigali, Nairobi. Cherono Ng'ok describes her project as an "emotional cartography," and her haunting, often colorful photographs explore the space between memory and imagination. For the International she will pair her iconic portrait of a white horse—in a decorative red halter, on a beach—with another image, still to be determined. Printed on wallpaper and installed in the museum's lobby, this billboard-sized work will draw viewers into the International, while a third photograph—printed on the back of the exhibition map—will go with them when they leave.
Visitors entering the International from the courtyard will immediately be immersed in sound—the sound, in fact, of the museum itself. New York-based artist Park McArthur has been tracking down the origins of CMOA's very stones, which are Larvikite—Norwegian rock valued for its pearlescent luster. McArthur dispatched a sound engineer to the Larvik quarry to record the ambient sounds of the site of extraction. She is shaping those sounds into an artwork that will envelop visitors as they arrive.
Carnegie International, 57th Edition, 2018 is presented by Bank of America. Major support has been provided by the Carnegie International Endowment, The Fine Foundation, and the Keystone Friends of the 2018 Carnegie International. Additional major support is provided by the Friends of the 2018 Carnegie International, the Jill and Peter Kraus Endowment for Contemporary Art, The Fellows of Carnegie Museum of Art, and the Louisa S. Rosenthal Family Fund.
General operating support for Carnegie Museum of Art is provided by The Heinz Endowments and Allegheny Regional Asset District. The programs of the Heinz Architectural Center are made possible by the generosity of the Drue Heinz Trust. Carnegie Museum of Art receives state arts funding support through a grant from the Pennsylvania Council on the Arts, a state agency funded by the Commonwealth of Pennsylvania.
Carnegie Museum of Art creates experiences that connect people to art, ideas, and one another.
We believe creativity is a defining human characteristic to which everyone should have access. CMOA collects, preserves, and presents artworks from around the world to inspire, sustain, and provoke discussion, and to engage and reflect multiple audiences.
Our world-class collection of over 30,000 works emphasizes art, architecture, photography, and design from the 19th century to the present. One of the four Carnegie Museums of Pittsburgh, Carnegie Museum of Art was founded by industrialist and philanthropist Andrew Carnegie in 1895. Learn more: call 412.622.3131 or visit cmoa.org.


text:
Update Report for Emergency Relief Activities in Nepal from AMDA Nepal
Here is the update Report for Emergency Relief Activities in Nepal from AMDA Nepal
The Great Earthquake Nepal, April 2015
Origin, Magnitude, Distribution and Impact
Nepal lies in a major earthquake beltt wher the India and Eurasia plates meet. The constant crashing of the two plates formed the Himalayan ranges and the region's last earthquake with high magnitude was in 1934.
The Earthquake occured at 11:56 A.M with its epicenter in Gorkha of Richter scale 7.6 - 7.9 on Saturday, April 25, 2015. Approximately, 110 aftershocks of more than 4 Richter scale were recorded between 11:56am on 25th April and 1:29am on 30th April. (Source:National Earthquake Center, Kathmandu.
The total number of districts with recorded deaths are 31 and the death toll as of May 1st, 2015 was 6,166 and injured was 13,232. The 31 districts with deaths are: Sindhupalchok, Kathmandu, Nuwakot, Gorkha, Dhading, Rasuwa, Kavre, Bhaktapur, Lalitpur, Dolakha, Makwanpur, Ramechhap, Solukhkhumbu, Okhaldhunga, Sindhuli, Sunsari, Chitwan, Bara, Parsa, Lamjung, Kaski, Morang, Bhojpur, Sarlahi, Dhanusa, Taplejung, Tanahun, Nawalparasi, Rukum, Rolpa, Rautahat.
The total household and total population of the above mentioned 31 districts were 2,878,319 (53.03% of total households of Nepal) and 13,652,804 (51.53% of total population of Nepal), respectively. World Heritage Sites (Kathmandu Durbar Square, Lalitpur Durbar Square, Bhaktapur Durbar Square, Pashupatinath Temple, Changu Narayan Temple, Swayambhunath Stupa, Bouddhanath Stupa) and other national heritages such as Dharahara (Bhimsen Tower), several temples, stupas and historical monuments were damaged severely. Fear was rampant in the affected areas. Injuries, suffocation, shock, acute anxiety, phobia, acute posttraumatic stress disorders, gastroenteritis, acute respiratory infections were observed to the affected population.
We noted that in almost all temporary camp dwellings drinking water was deficient in an already water deficit Kathmandu. People went in search of drinking water but all shops were closed. Electricity supply was interrupted for various durations depending upon the locality. Telephones were functioning despite the nature of the earthquake. Government declared a state of emergency but no basic facilities were available in the ravaged area.
Rescue operations by several national and international agencies have been involved in the severed areas. Security agencies such as Armed Police Force (APF), Nepal Army (NA), Nepal Police and Radio Nepal have been performing exemplarily. Nepal government has released 1.3 billion Nepalese Rupees for immediate relief.
AMDA activities in Nepal
AMDA started its relief activities within 48 hours of earthquake in Nepal. AMDA Nepal mobilized all its resources. Several activities were conducted. AMDA Nepal got involved in medical and humanitarian rescue in Dhobidhara, Sakhu of Kathmandu (April 26), Gorkha (April 27), Sindhupalchok (April 29), Sankhu and Visinity of Kathmandu (April 28), Gongabu, Narayangopalchowk, Chuchepati of Kathmandu (April 30), Kalopati, Jhounkel, Changu, Byasi of Bhaktapur (May 1), Pashupatinath Temple area and Kirtipur of Kathmandu, Khokana and Lubu of Lalitpur (May 2) and Dharmasthali of Kathmandu (May 3).
AMDA Nepal doctors in various hospitals have been trying their best in respective hospitals. Considering the gravity and the magnitude of the situation, AMDA International President Dr. Suganami arrived in Kathmandu on May 1st with his team.
Exemplary work was conducted by AMDA Nepal along with CMDC in Changu Narayan area where very negligible support from government, NGOs/INGOs had reached. AMDA distributed oral rehydration solution (ORS), paracetamol tablets, antibiotic ointments, antacid, mineral water along with dry food. AMDA members sympathized as well as motivated the victims.
Immediate (0-4 weeks) needs are removal and cremation of the dead, treatment of the injured/victims, mass mobilization of medical support, alertness of fire brigade, security of victims/affected population, control of infectious diseases, preventive measures, mass awareness, prompt communication and transportation, distribution of rescue materials, safe management of air, water, toilet, crowd, shelter and fear. Mass communication of the incidence and prevention of rumors is equally important. Government security organizations, general people, international organizations are working hard to achieve the mentioned needs. Governmental organizations lacked rescue operations in several areas as per the need of the hour according to many people and media. Fast methodology instead of old bureaucracy is required for smooth rescue operation in this geographically diverse country.
Health and medical activities, treatment and prevention of psychological trauma, material supports were noted as short term needs (4 to 12 weeks). A long term planning, awareness and research is mandatory in the geologically disaster-prone area.
Since Nepal is located in an earthquake zone she should always remain alert. AMDA stands for emergency humanitarian support and has a long history of rescue activities. It started its activities from day two of The Great Earthquake Nepal, April 2015 through its dedicated members.
Prompt, integrated, coordinated and precise rescue operation was urgent to reduce mortality, morbidity, disability, stress disorder and material loss. We observed courageous helping individuals/ families rising to the needs of their countrymen. Immediate rescue services, financial support directly to the affected individuals, families and institutions in a transparent and sincere manner are recommended. Communication therapy helps to prevent undue stress in the public.
Art and culture is not sustainable long without proper utilization of science and technology neither can it uplift the living standard of people. Also, a need to distinguish residential, business, industrial zones were noted to prevent further damage in the future. Spending a lot of money in reconstructing lost monuments may invite further poverty in this scientifically poorly aware society.
Prompt rescue, scientific awareness, disaster preparedness, renovation, reconstruction, innovation and better life can be achieved by performing what one thinks and talks. Peace of mind, healthy body and environment are the tools to achieve these goals in this globally popular country.


This app has exceeded my expectations on all counts. Documents, receipts, etc, all scanned perfectly and were easy to transmit.
I love having this scanner on my mobile device because i don't have to wait to get to a scanning machine. The image is as clear as a real scanner!
Really appreciate this app and it's ability to link to Google Drive.
This app saves me tons of time. I use it almost daily for capturing documents and keeping them organized. And I love the workflows.
This app is so convenient, fast and accurate that I now use it to scan all my documents. There is no need for a physical scanner anymore.